API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 27th, 2016
40
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 29.00 KB | None | 0 0
raw download clone embed print report
  1. import com.nolimitscoaster.*;
  2.  
  3. public class BlockScript extends Script implements BlockSystemController, TrackTriggerListener {
  4.     private static final int STATE_BLOCK_FREE = 0;
  5.     private static final int STATE_BLOCK_APPROACHING = 1;
  6.     private static final int STATE_BLOCK_LEAVING = 2;
  7.     private static final int STATE_BLOCK_BEFORE_TRIGGER = 3;
  8.     private static final int STATE_BLOCK_BEHIND_TRIGGER = 4;
  9.     private static final int STATE_BLOCK_WAITING = 5;
  10.     private static final int STATE_BLOCK_WAIT_FOR_CLEAR = 6;
  11.     private static final int STATE_BLOCK_WAIT_FOR_ADVANCE = 7;
  12.     private static final int STATE_BLOCK_IN_STATION = 8;
  13.     private static final int STATE_BLOCK_APPROACHING_B = 9;
  14.     private static final int STATE_BLOCK_LEAVING_B = 10;
  15.     private static final int STATE_BLOCK_BEFORE_TRIGGER_B = 11;
  16.     private static final int STATE_LAUNCH_WAITING = 12;
  17.     private static final int STATE_LAUNCH_BACKWARDS = 13;
  18.     private static final int STATE_LAUNCH_BACKWARDS_READY = 14;
  19.     private static final int STATE_LAUNCH_READY = 15;
  20.    
  21.     private static final String scriptName = "BlockScript";
  22.    
  23.     private static final int AUTO_MODE = 0;
  24.     private static final int MANUAL_BLOCK_MODE = 1;
  25.     private static final int FULL_MANUAL_MODE = 2;
  26.    
  27.     private Coaster coaster;
  28.     private Block stationEnterBlock;
  29.     private Block launchBlock;
  30.     private Block zoneABlock;
  31.     private Block zoneBBlock;
  32.     private Block brakerunABlock;
  33.     private Block brakerunBBlock;
  34.     private Block stationExitBlock;
  35.     private Block storageABlock;
  36.     private Block storageBBlock;
  37.     private SpecialTrack storageSwitch;
  38.     private float launchBlockTime;
  39.     private float launchBlockTimeSequence;
  40.     private int mode;
  41.    
  42.     private TrackTrigger launchOccupiedEnableTrigger;
  43.     private TrackTrigger launchOccupiedDisableTrigger;
  44.     private TrackTrigger zoneAOccupiedTrigger;
  45.     private TrackTrigger zoneAClearTrigger;
  46.     private TrackTrigger launchBackwardsTrigger;
  47.     private TrackTrigger launchBackwardsReadyTrigger;
  48.    
  49.     private bool launchOccupied = false;
  50.     private bool zoneAOccupied = false;
  51.     private bool launchBackwards = false;
  52.     private bool launchBackwardsReady = false;
  53.     private bool launchFullyReady = false;
  54.    
  55.     public bool onInit() {
  56.         String name;
  57.        
  58.         coaster = sim.getCoasterForEntityId(getParentEntityId());
  59.         if (coaster == null) {
  60.             System.err.println(scriptName + ": Not attached to coaster.");
  61.             return false;
  62.         }
  63.        
  64.         coaster.setBlockSystemController(this);
  65.        
  66.         name = "Station Enter";
  67.         stationEnterBlock = coaster.getBlock(name);
  68.         if (!checkAndSetInitialBlockState(stationEnterBlock, name)) {
  69.             return false;
  70.         }
  71.         stationEnterBlock.setAdvanceFwdVisible(true);
  72.        
  73.         name = "Launch";
  74.         launchBlock = coaster.getBlock(name);
  75.         if (!checkAndSetInitialBlockState(launchBlock, name)) {
  76.             return false;
  77.         }
  78.         launchBlock.setAdvanceFwdVisible(true);
  79.        
  80.         name = "Zone A";
  81.         zoneABlock = coaster.getBlock(name);
  82.         if (!checkAndSetInitialBlockState(zoneABlock, name)) {
  83.             return false;
  84.         }
  85.         zoneABlock.setAdvanceFwdVisible(true);
  86.        
  87.         name = "Zone B";
  88.         zoneBBlock = coaster.getBlock(name);
  89.         if (!checkAndSetInitialBlockState(zoneBBlock, name)) {
  90.             return false;
  91.         }
  92.         zoneBBlock.setAdvanceFwdVisible(true);
  93.        
  94.         name = "Brakerun A";
  95.         brakerunABlock = coaster.getBlock(name);
  96.         if (!checkAndSetInitialBlockState(brakerunABlock, name)) {
  97.             return false;
  98.         }
  99.         brakerunABlock.setAdvanceFwdVisible(true);
  100.        
  101.         name = "Brakerun B";
  102.         brakerunBBlock = coaster.getBlock(name);
  103.         if (!checkAndSetInitialBlockState(brakerunBBlock, name)) {
  104.             return false;
  105.         }
  106.         brakerunBBlock.setAdvanceFwdVisible(true);
  107.        
  108.         name = "Station Exit";
  109.         stationExitBlock = coaster.getBlock(name);
  110.         if (!checkAndSetInitialBlockState(stationExitBlock, name)) {
  111.             return false;
  112.         }
  113.         stationExitBlock.setAdvanceFwdVisible(true);
  114.         stationExitBlock.setAdvanceBwdVisible(true);
  115.        
  116.         name = "Storage A";
  117.         storageABlock = coaster.getBlock(name);
  118.         if (!checkAndSetInitialBlockState(storageABlock, name)) {
  119.             return false;
  120.         }
  121.         storageABlock.setAdvanceFwdVisible(true);
  122.         storageABlock.setAdvanceBwdVisible(true);
  123.        
  124.         name = "Storage B";
  125.         storageBBlock = coaster.getBlock(name);
  126.         if (!checkAndSetInitialBlockState(storageBBlock, name)) {
  127.             return false;
  128.         }
  129.         storageBBlock.setAdvanceFwdVisible(true);
  130.        
  131.         name = "Storage Switch";
  132.         storageSwitch = coaster.getSpecialTrack(name);
  133.         if (storageSwitch == null) {
  134.             System.err.println(scriptName + ": SpecialTrack '" + name + "' not found.");
  135.             return false;
  136.         }
  137.        
  138.         launchOccupiedEnableTrigger = coaster.getTrackTrigger("TriggerTrainBeforeLaunch");
  139.         if (launchOccupiedEnableTrigger == null) {
  140.             System.err.println(scriptName + ": Trigger not found!");
  141.             return false;
  142.         }
  143.         launchOccupiedEnableTrigger.addTrackTriggerListener(this);
  144.        
  145.         launchOccupiedDisableTrigger = coaster.getTrackTrigger("TriggerTrainAfterLaunch");
  146.         if (launchOccupiedDisableTrigger == null) {
  147.             System.err.println(scriptName + ": Trigger not found!");
  148.             return false;
  149.         }
  150.         launchOccupiedDisableTrigger.addTrackTriggerListener(this);
  151.        
  152.         zoneAOccupiedTrigger = coaster.getTrackTrigger("TriggerZoneAOccupied");
  153.         if (zoneAOccupiedTrigger == null) {
  154.             System.err.println(scriptName + ": Trigger not found!");
  155.             return false;
  156.         }
  157.         zoneAOccupiedTrigger.addTrackTriggerListener(this);
  158.        
  159.         zoneAClearTrigger = coaster.getTrackTrigger("TriggerZoneAClear");
  160.         if (zoneAClearTrigger == null) {
  161.             System.err.println(scriptName + ": Trigger not found!");
  162.             return false;
  163.         }
  164.         zoneAClearTrigger.addTrackTriggerListener(this);
  165.        
  166.         launchBackwardsTrigger = coaster.getTrackTrigger("TriggerLaunchBackwards");
  167.         if (launchBackwardsTrigger == null) {
  168.             System.err.println(scriptName + ": Trigger not found!");
  169.             return false;
  170.         }
  171.         launchBackwardsTrigger.addTrackTriggerListener(this);
  172.        
  173.         launchBackwardsReadyTrigger = coaster.getTrackTrigger("TriggerLaunchBackwardsReady");
  174.         if (launchBackwardsReadyTrigger == null) {
  175.             System.err.println(scriptName + ": Trigger not found!");
  176.             return false;
  177.         }
  178.         launchBackwardsReadyTrigger.addTrackTriggerListener(this);
  179.        
  180.         mode = AUTO_MODE;
  181.        
  182.         return true;
  183.     }
  184.    
  185.     public void onExit() {
  186.        
  187.     }
  188.    
  189.     public void onNextFrame(float tick) {
  190.         System.out.println(launchBackwards + " / " + launchBackwardsReady + " / " + launchBlock.getState() + " / " + launchBlockTime + " / " + launchBlockTimeSequence);
  191.         if (mode != FULL_MANUAL_MODE) {
  192.             processStation(stationEnterBlock, launchBlock);
  193.             processLaunchBlock();
  194.             processAfterLaunchEmergencyBlock();
  195.             processZoneABlock();
  196.             processZoneBBlock();
  197.             processBrakerunABlock();
  198.             processBrakerunBBlock();
  199.             processStation(stationExitBlock, stationEnterBlock);
  200.             processStorageABlock();
  201.             processStorageBBlock();
  202.            
  203.             if (mode == MANUAL_BLOCK_MODE) {
  204.                 updateControlPanel();
  205.             }
  206.         }
  207.     }
  208.    
  209.     public void onAutoMode(Coaster c) {
  210.         if (mode == FULL_MANUAL_MODE) {
  211.             setInitialBlockState(stationEnterBlock);
  212.             setInitialBlockState(launchBlock);
  213.             setInitialBlockState(zoneABlock);
  214.             setInitialBlockState(zoneBBlock);
  215.             setInitialBlockState(brakerunABlock);
  216.             setInitialBlockState(brakerunBBlock);
  217.             setInitialBlockState(stationExitBlock);
  218.             setInitialBlockState(storageABlock);
  219.             setInitialBlockState(storageBBlock);
  220.         }
  221.        
  222.         mode = AUTO_MODE;
  223.         updateControlPanel();
  224.     }
  225.    
  226.     public void onManualBlockMode(Coaster c) {
  227.         if (mode == FULL_MANUAL_MODE) {
  228.             setInitialBlockState(stationEnterBlock);
  229.             setInitialBlockState(launchBlock);
  230.             setInitialBlockState(zoneABlock);
  231.             setInitialBlockState(zoneBBlock);
  232.             setInitialBlockState(brakerunABlock);
  233.             setInitialBlockState(brakerunBBlock);
  234.             setInitialBlockState(stationExitBlock);
  235.             setInitialBlockState(storageABlock);
  236.             setInitialBlockState(storageBBlock);
  237.         }
  238.        
  239.         mode = MANUAL_BLOCK_MODE;
  240.         updateControlPanel();
  241.     }
  242.    
  243.     public void onFullManualMode(Coaster c) {
  244.         mode = FULL_MANUAL_MODE;
  245.         updateControlPanel();
  246.     }
  247.    
  248.     public void onAdvanceFWDButton(Block block) {
  249.         if (block == stationEnterBlock) {
  250.             launchBlock.setState(STATE_BLOCK_APPROACHING);
  251.             stationEnterBlock.setState(STATE_BLOCK_LEAVING);
  252.             stationEnterBlock.getSection().setStationLeaving();
  253.         } else if (block == launchBlock) {
  254.             zoneABlock.setState(STATE_BLOCK_APPROACHING);
  255.             launchBlock.setState(STATE_BLOCK_LEAVING);
  256.         } else if (block == zoneABlock) {
  257.             zoneBBlock.setState(STATE_BLOCK_APPROACHING);
  258.             zoneABlock.setState(STATE_BLOCK_LEAVING);
  259.         } else if (block == zoneBBlock) {
  260.             brakerunABlock.setState(STATE_BLOCK_APPROACHING);
  261.             zoneBBlock.setState(STATE_BLOCK_LEAVING);
  262.         } else if (block == brakerunABlock) {
  263.             brakerunBBlock.setState(STATE_BLOCK_APPROACHING);
  264.             brakerunABlock.setState(STATE_BLOCK_LEAVING);
  265.         } else if (block == brakerunBBlock) {
  266.             stationExitBlock.setState(STATE_BLOCK_APPROACHING);
  267.             brakerunBBlock.setState(STATE_BLOCK_LEAVING);
  268.         } else if (block == stationExitBlock) {
  269.             stationEnterBlock.setState(STATE_BLOCK_APPROACHING);
  270.             stationExitBlock.setState(STATE_BLOCK_LEAVING);
  271.             stationExitBlock.getSection().setStationLeaving();
  272.         } else if (block == storageABlock) {
  273.             Train train = block.getSection().getTrainOnSection();
  274.             if (train != null) train.setLashedToTrack(false);
  275.             stationExitBlock.setState(STATE_BLOCK_APPROACHING);
  276.             storageABlock.setState(STATE_BLOCK_LEAVING);
  277.         } else if (block == storageBBlock) {
  278.             Train train = block.getSection().getTrainOnSection();
  279.             if (train != null) train.setLashedToTrack(false);
  280.             storageABlock.setState(STATE_BLOCK_APPROACHING);
  281.             storageBBlock.setState(STATE_BLOCK_LEAVING);
  282.         }
  283.     }
  284.    
  285.     public void onAdvanceBWDButton(Block block) {
  286.         if (block == stationExitBlock) {
  287.             storageABlock.setState(STATE_BLOCK_APPROACHING);
  288.             stationExitBlock.setState(STATE_BLOCK_LEAVING_B);
  289.             stationExitBlock.getSection().setStationLeaving();
  290.         } else if (block == storageABlock) {
  291.             Train train = block.getSection().getTrainOnSection();
  292.             if (train != null) train.setLashedToTrack(false);
  293.             storageBBlock.setState(STATE_BLOCK_APPROACHING);
  294.             storageABlock.setState(STATE_BLOCK_LEAVING);
  295.         }
  296.     }
  297.    
  298.     private static bool checkAndSetInitialBlockState(Block block, String name) {
  299.         if (block == null) {
  300.             System.err.println(scriptName + ": Block '" + name + "' not found.");
  301.             return false;
  302.         }
  303.         registerBlockStates(block);
  304.         setInitialBlockState(block);
  305.         return true;
  306.     }
  307.    
  308.     private static void setInitialBlockState(Block block) {
  309.         if (block.getNumberOfTrainsOnBlock() > 0) {
  310.             if (block.getSection().iStation()) {
  311.                 block.setState(STATE_BLOCK_IN_STATION);
  312.             } else {
  313.                 block.setState(STATE_BLOCK_WAIT_FOR_CLEAR);
  314.             }
  315.         } else {
  316.             block.setState(STATE_BLOCK_FREE);
  317.         }
  318.     }
  319.    
  320.     private static void registerBlockStates(Block block) {
  321.         block.registerState(STATE_BLOCK_FREE, "Free", Block.LAMP_OFF);
  322.    
  323.         block.registerState(STATE_BLOCK_APPROACHING, "Approaching", Block.LAMP_FLASHING);
  324.         block.registerState(STATE_BLOCK_APPROACHING_B, "Approaching", Block.LAMP_FLASHING);
  325.    
  326.         block.registerState(STATE_BLOCK_LEAVING, "Leaving", Block.LAMP_ON);
  327.         block.registerState(STATE_BLOCK_LEAVING_B, "Leaving B", Block.LAMP_ON);
  328.    
  329.         block.registerState(STATE_BLOCK_BEFORE_TRIGGER, "Before Trigger", Block.LAMP_ON);
  330.         block.registerState(STATE_BLOCK_BEFORE_TRIGGER_B, "Before Trigger", Block.LAMP_ON);
  331.    
  332.         block.registerState(STATE_BLOCK_BEHIND_TRIGGER, "Behind Trigger", Block.LAMP_ON);
  333.    
  334.         block.registerState(STATE_BLOCK_WAITING, "Waiting", Block.LAMP_ON);
  335.         block.registerState(STATE_BLOCK_WAIT_FOR_CLEAR, "Waiting for Clear Block", Block.LAMP_ON);
  336.         block.registerState(STATE_BLOCK_WAIT_FOR_ADVANCE, "Waiting for Advance", Block.LAMP_ON);
  337.  
  338.         block.registerState(STATE_BLOCK_IN_STATION, "In Station", Block.LAMP_ON);
  339.     }
  340.    
  341.     private void updateControlPanel() {
  342.         stationEnterBlock.setAdvanceFwdEnabled(stationEnterBlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE);
  343.         launchBlock.setAdvanceFwdEnabled(launchBlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE);
  344.         zoneABlock.setAdvanceFwdEnabled(zoneABlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE);
  345.         zoneBBlock.setAdvanceFwdEnabled(zoneBBlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE);
  346.         brakerunABlock.setAdvanceFwdEnabled(brakerunABlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE);
  347.         brakerunBBlock.setAdvanceFwdEnabled((brakerunBBlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE) && canBrakeMoveForward());
  348.         stationExitBlock.setAdvanceFwdEnabled(stationExitBlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE);
  349.         stationExitBlock.setAdvanceBwdEnabled((stationExitBlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE) && canExitMoveBackward());
  350.         storageABlock.setAdvanceFwdEnabled((storageABlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE) && canStorageMoveForward());
  351.         storageABlock.setAdvanceBwdEnabled(storageABlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE);
  352.         storageBBlock.setAdvanceFwdEnabled(storageBBlock.getState() == STATE_BLOCK_WAIT_FOR_ADVANCE);
  353.     }
  354.    
  355.     private void processStation(Block stationBlock, Block nextBlock) {
  356.         switch (stationBlock.getState()) {
  357.             case STATE_BLOCK_IN_STATION:
  358.                 if (stationBlock.getSection().isStationWaitingForClearBlock()) {
  359.                     if (nextBlock.getState() == STATE_BLOCK_FREE) {
  360.                         if ((stationBlock.getName() == "Station Exit") || !launchOccupied) {
  361.                             stationBlock.getSection().setStationNextBlockClear();
  362.                         }
  363.                     }
  364.                 } else if (stationBlock.getSection().isStationWaitingForAdvance()) {
  365.                     if (mode == MANUAL_BLOCK_MODE) {
  366.                         if (nextBlock.getState() == STATE_BLOCK_FREE) {
  367.                             stationBlock.setState(STATE_BLOCK_WAIT_FOR_ADVANCE);
  368.                         } else {
  369.                             stationBlock.getSection().setStationNextBlockOccupied();
  370.                         }
  371.                     } else {
  372.                         if (nextBlock.getState() == STATE_BLOCK_FREE) {
  373.                             nextBlock.setState(STATE_BLOCK_APPROACHING);
  374.                             stationBlock.setState(STATE_BLOCK_LEAVING);
  375.                             stationBlock.getSection().setStationLeaving();
  376.                         } else {
  377.                             stationBlock.getSection().setStationNextBlockOccupied();
  378.                         }
  379.                     }
  380.                 }
  381.                 break;
  382.            
  383.             case STATE_BLOCK_WAIT_FOR_ADVANCE:
  384.                 if ((mode != MANUAL_BLOCK_MODE) || !stationBlock.getSection().isStationWaitingForAdvance() || (nextBlock.getState() != STATE_BLOCK_FREE)) {
  385.                     stationBlock.setState(STATE_BLOCK_IN_STATION);
  386.                 }
  387.                 break;
  388.            
  389.             case STATE_BLOCK_LEAVING:
  390.                 if (stationBlock.getNumberOfTrainsOnBlock() != 0) {
  391.                     stationBlock.getSection().setBrakesOff();
  392.                     stationBlock.getSection().setTransportsStandardFwdOn();
  393.                 } else {
  394.                     stationBlock.setState(STATE_BLOCK_FREE);
  395.                 }
  396.                 break;
  397.            
  398.             case STATE_BLOCK_LEAVING_B:
  399.                 if (stationBlock.getNumberOfTrainsOnBlock() != 0) {
  400.                     stationBlock.getSection().setBrakesOff();
  401.                     stationBlock.getSection().setTransportsStandardBwdOn();
  402.                 } else {
  403.                     stationBlock.setState(STATE_BLOCK_FREE);
  404.                 }
  405.                 break;
  406.            
  407.             case STATE_BLOCK_FREE:
  408.                 stationBlock.getSection().setTransportsOff();
  409.                 stationBlock.getSection().setBrakesOn();
  410.                 break;
  411.            
  412.             case STATE_BLOCK_APPROACHING:
  413.                 if (stationBlock.getSection().isTrainOnSection()) {
  414.                     stationBlock.getSection().setStationEntering(); //TODO Custom station entering
  415.                     stationBlock.setState(STATE_BLOCK_IN_STATION);
  416.                 } else {
  417.                     stationBlock.getSection().setBrakesOff();
  418.                     stationBlock.getSection().setTransportsOff();
  419.                 }
  420.                 break;
  421.         }
  422.     }
  423.    
  424.     private void processLaunchBlock() {
  425.         switch (launchBlock.getState()) {
  426.             case STATE_BLOCK_APPROACHING:
  427.                 launchBlock.getSection().setBrakesOff();
  428.                 launchBlock.getSection().setTransportsOff();
  429.                 if (launchBlock.getSection().isTrainOnSection()) {
  430.                     launchBlock.setState(STATE_BLOCK_BEFORE_TRIGGER);
  431.                 }
  432.                 break;
  433.            
  434.             case STATE_BLOCK_BEFORE_TRIGGER:
  435.                 launchBlock.getSection().setBrakesTrim();
  436.                 launchBlock.getSection().setTransportsStandardFwdDependingOnBrake();
  437.                 if (launchBlock.getSection().isTrainBehindBrakeTrigger()) {
  438.                     launchBlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  439.                 }
  440.                 break;
  441.            
  442.             case STATE_BLOCK_BEHIND_TRIGGER:
  443.                 launchBlock.getSection().setBrakesOn();
  444.                 launchBlock.getSection().setTransportsOff();
  445.                
  446.                 Train train = launchBlock.getSection().getTrainOnSection();
  447.                 if (train.getSpeed() == 0) {
  448.                     launchBlockTime = 0;
  449.                     launchBlock.setState(STATE_BLOCK_WAITING);
  450.                 }
  451.                 break;
  452.            
  453.             case STATE_BLOCK_WAITING:
  454.                 //OLD CODE
  455.                 ///////////
  456.                 //launchBlock.getSection().setBrakesOn();
  457.                 //launchBlock.getSection().setTransportsOff();
  458.                 //launchBlockTime += sim.getCurSimulationTickSec();
  459.                 //if (launchBlockTime >= launchBlock.getSection().getBrakeWaitTime()) {
  460.                 //  launchBlock.setState(STATE_BLOCK_WAIT_FOR_CLEAR);
  461.                 //}
  462.                 if (!zoneAOccupied) {
  463.                     launchBlock.setState(STATE_LAUNCH_WAITING);
  464.                 }
  465.                
  466.                 break;
  467.            
  468.             case STATE_LAUNCH_WAITING:
  469.                 launchBlock.getSection().setTransportsOff();
  470.                 launchBlock.getSection().setBrakesOn();
  471.                 launchBlockTime += sim.getCurSimulationTickSec();
  472.                
  473.                 if (launchBlockTime >= 5.0f) {
  474.                     launchBlock.setState(STATE_LAUNCH_BACKWARDS);
  475.                 }
  476.                 break;
  477.            
  478.             case STATE_LAUNCH_BACKWARDS:
  479.                 launchBlock.getSection().setTransportsStandardBwdOn();
  480.                 launchBlock.getSection().setBrakesOff();
  481.                
  482.                 if (launchBackwardsReady) {
  483.                     launchBlockTimeSequence = 0;
  484.                     launchBlock.setState(STATE_LAUNCH_BACKWARDS_READY);
  485.                 }
  486.                 break;
  487.            
  488.             case STATE_LAUNCH_BACKWARDS_READY:
  489.                 launchBlock.getSection().setTransportsOff();
  490.                 launchBlock.getSection().setBrakesOn();
  491.                
  492.                 launchBlockTimeSequence += sim.getCurSimulationTickSec();
  493.                
  494.                 if (launchBlockTimeSequence >= 10) {
  495.                     launchBlock.setState(STATE_LAUNCH_READY);
  496.                 }
  497.                 break;
  498.            
  499.             case STATE_LAUNCH_READY:
  500.                 launchBlock.getSection().setTransportsLaunchFwdOn();
  501.                 launchBlock.getSection().setBrakesOff();
  502.                 launchBlock.setState(STATE_BLOCK_WAIT_FOR_CLEAR);
  503.                 break;
  504.            
  505.             case STATE_BLOCK_WAIT_FOR_CLEAR:
  506.                 launchBlock.getSection().setBrakesOn();
  507.                 launchBlock.getSection().setTransportsOff();
  508.                 if (mode == MANUAL_BLOCK_MODE) {
  509.                     launchBlock.setState(STATE_BLOCK_WAIT_FOR_ADVANCE);
  510.                 } else {
  511.                     zoneABlock.setState(STATE_BLOCK_APPROACHING);
  512.                     launchBlock.setState(STATE_BLOCK_LEAVING);
  513.                 }
  514.                 break;
  515.            
  516.             case STATE_BLOCK_WAIT_FOR_ADVANCE:
  517.                 launchBlock.getSection().setBrakesOn();
  518.                 launchBlock.getSection().setTransportsOff();
  519.                 break;
  520.            
  521.             case STATE_BLOCK_LEAVING:
  522.                 if (launchBlock.getSection().isTrainOnSection()) {
  523.                     launchBlock.getSection().setBrakesOff();
  524.                     launchBlock.getSection().setTransportsLaunchFwdOn();
  525.                 } else {
  526.                     launchBlock.getSection().setBrakesOn();
  527.                     launchBlock.getSection().setTransportsOff();
  528.                 }
  529.                
  530.                 if (launchBlock.getNumberOfTrainsOnBlock() == 0) {
  531.                     launchBlock.setState(STATE_BLOCK_FREE);
  532.                 }
  533.                 break;
  534.            
  535.             case STATE_BLOCK_FREE:
  536.                 launchBlock.getSection().setBrakesOn();
  537.                 launchBlock.getSection().setTransportsOff();
  538.                 break;
  539.         }
  540.     }
  541.    
  542.     private void processAfterLaunchEmergencyBlock() {
  543.         if (Master.isFailure()) {
  544.             coaster.getBlock("After Launch Emergency Brakes").getSection().setBrakesOn();
  545.         } else {
  546.             coaster.getBlock("After Launch Emergency Brakes").getSection().setBrakesOff();
  547.         }
  548.     }
  549.    
  550.     private void processZoneABlock() {
  551.         switch (zoneABlock.getState()) {
  552.             case STATE_BLOCK_FREE:
  553.                 zoneABlock.getSection().setTransportsOff();
  554.                 zoneABlock.getSection().setBrakesOn();
  555.                 break;
  556.            
  557.             case STATE_BLOCK_APPROACHING:
  558.                 if (zoneABlock.getSection().isTrainOnSection()) {
  559.                     zoneABlock.setState(STATE_BLOCK_BEFORE_TRIGGER);
  560.                 } else {
  561.                     zoneABlock.getSection().setBrakesOff();
  562.                     zoneABlock.getSection().setTransportsOff();
  563.                 }
  564.                 break;
  565.            
  566.             case STATE_BLOCK_BEFORE_TRIGGER:
  567.                 zoneABlock.getSection().setBrakesTrim();
  568.                 zoneABlock.getSection().setTransportsStandardFwdDependingOnBrake();
  569.                 if (zoneABlock.getSection().isTrainBehindBrakeTrigger()) {
  570.                     zoneABlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  571.                 }
  572.                 break;
  573.            
  574.             case STATE_BLOCK_BEHIND_TRIGGER:
  575.                 if (mode == MANUAL_BLOCK_MODE) {
  576.                     zoneABlock.getSection().setTransportsOff();
  577.                     zoneABlock.getSection().setBrakesOn();
  578.                     zoneABlock.setState(STATE_BLOCK_WAIT_FOR_ADVANCE);
  579.                 } else {
  580.                     if (mode == AUTO_MODE) {
  581.                         zoneBBlock.setState(STATE_BLOCK_APPROACHING);
  582.                         zoneABlock.setState(STATE_BLOCK_LEAVING);
  583.                     } else {
  584.                         zoneABlock.getSection().setTransportsOff();
  585.                         zoneABlock.getSection().setBrakesOn();
  586.                     }
  587.                 }
  588.                 break;
  589.            
  590.             case STATE_BLOCK_WAIT_FOR_ADVANCE:
  591.                 if (mode == AUTO_MODE) {
  592.                     zoneABlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  593.                 } else {
  594.                     zoneABlock.getSection().setTransportsOff();
  595.                     zoneABlock.getSection().setBrakesOn();
  596.                 }
  597.                 break;
  598.            
  599.             case STATE_BLOCK_LEAVING:
  600.                 zoneABlock.getSection().setBrakesOff();
  601.                 zoneABlock.getSection().setTransportsStandardFwdDependingOnBrake();
  602.                 if (zoneABlock.getNumberOfTrainsOnBlock() == 0) {
  603.                     zoneABlock.setState(STATE_BLOCK_FREE);
  604.                 }
  605.                 break;
  606.            
  607.             case STATE_BLOCK_WAIT_FOR_CLEAR:
  608.                 if (zoneABlock.getSection().isTrainBehindBrakeTrigger()) {
  609.                     zoneABlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  610.                 } else {
  611.                     zoneABlock.setState(STATE_BLOCK_BEFORE_TRIGGER);
  612.                 }
  613.                 break;
  614.         }
  615.     }
  616.    
  617.     private void processZoneBBlock() {
  618.         switch (zoneBBlock.getState()) {
  619.             case STATE_BLOCK_FREE:
  620.                 zoneBBlock.getSection().setTransportsOff();
  621.                 zoneBBlock.getSection().setBrakesOn();
  622.                 break;
  623.            
  624.             case STATE_BLOCK_APPROACHING:
  625.                 if (zoneBBlock.getSection().isTrainOnSection()) {
  626.                     zoneBBlock.setState(STATE_BLOCK_BEFORE_TRIGGER);
  627.                 } else {
  628.                     zoneBBlock.getSection().setBrakesOff();
  629.                     zoneBBlock.getSection().setTransportsOff();
  630.                 }
  631.                 break;
  632.            
  633.             case STATE_BLOCK_BEFORE_TRIGGER:
  634.                 zoneBBlock.getSection().setBrakesTrim();
  635.                 zoneBBlock.getSection().setTransportsStandardFwdDependingOnBrake();
  636.                 if (zoneBBlock.getSection().isTrainBehindBrakeTrigger()) {
  637.                     zoneBBlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  638.                 }
  639.                 break;
  640.            
  641.             case STATE_BLOCK_BEHIND_TRIGGER:
  642.                 if (mode == MANUAL_BLOCK_MODE) {
  643.                     zoneBBlock.getSection().setTransportsOff();
  644.                     zoneBBlock.getSection().setBrakesOn();
  645.                     zoneBBlock.setState(STATE_BLOCK_WAIT_FOR_ADVANCE);
  646.                 } else {
  647.                     if (mode == AUTO_MODE) {
  648.                         brakerunABlock.setState(STATE_BLOCK_APPROACHING);
  649.                         zoneBBlock.setState(STATE_BLOCK_LEAVING);
  650.                     } else {
  651.                         zoneBBlock.getSection().setTransportsOff();
  652.                         zoneBBlock.getSection().setBrakesOn();
  653.                     }
  654.                 }
  655.                 break;
  656.            
  657.             case STATE_BLOCK_WAIT_FOR_ADVANCE:
  658.                 if (mode == AUTO_MODE) {
  659.                     zoneBBlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  660.                 } else {
  661.                     zoneBBlock.getSection().setTransportsOff();
  662.                     zoneBBlock.getSection().setBrakesOn();
  663.                 }
  664.                 break;
  665.            
  666.             case STATE_BLOCK_LEAVING:
  667.                 zoneBBlock.getSection().setBrakesOff();
  668.                 zoneBBlock.getSection().setTransportsStandardFwdDependingOnBrake();
  669.                 if (zoneBBlock.getNumberOfTrainsOnBlock() == 0) {
  670.                     zoneBBlock.setState(STATE_BLOCK_FREE);
  671.                 }
  672.                 break;
  673.            
  674.             case STATE_BLOCK_WAIT_FOR_CLEAR:
  675.                 if (zoneBBlock.getSection().isTrainBehindBrakeTrigger()) {
  676.                     zoneBBlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  677.                 } else {
  678.                     zoneBBlock.setState(STATE_BLOCK_BEFORE_TRIGGER);
  679.                 }
  680.                 break;
  681.         }
  682.     }
  683.    
  684.     private void processBrakerunABlock() {
  685.         switch (brakerunABlock.getState()) {
  686.             case STATE_BLOCK_FREE:
  687.                 brakerunABlock.getSection().setTransportsOff();
  688.                 brakerunABlock.getSection().setBrakesOn();
  689.                 break;
  690.            
  691.             case STATE_BLOCK_APPROACHING:
  692.                 if (brakerunABlock.getSection().isTrainOnSection()) {
  693.                     brakerunABlock.setState(STATE_BLOCK_BEFORE_TRIGGER);
  694.                 } else {
  695.                     brakerunABlock.getSection().setBrakesOff();
  696.                     brakerunABlock.getSection().setTransportsOff();
  697.                 }
  698.                 break;
  699.            
  700.             case STATE_BLOCK_BEFORE_TRIGGER:
  701.                 brakerunABlock.getSection().setBrakesTrim();
  702.                 brakerunABlock.getSection().setTransportsStandardFwdDependingOnBrake();
  703.                 if (brakerunABlock.getSection().isTrainBehindBrakeTrigger()) {
  704.                     brakerunABlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  705.                 }
  706.                 break;
  707.            
  708.             case STATE_BLOCK_BEHIND_TRIGGER:
  709.                 if (brakerunBBlock.getState() == STATE_BLOCK_FREE) {
  710.                     if (mode == MANUAL_BLOCK_MODE) {
  711.                         brakerunABlock.getSection().setTransportsOff();
  712.                         brakerunABlock.getSection().setBrakesOn();
  713.                         brakerunABlock.setState(STATE_BLOCK_WAIT_FOR_ADVANCE);
  714.                     } else {
  715.                         if (mode == AUTO_MODE) {
  716.                             brakerunBBlock.setState(STATE_BLOCK_APPROACHING);
  717.                             brakerunABlock.setState(STATE_BLOCK_LEAVING);
  718.                         } else {
  719.                             brakerunABlock.getSection().setTransportsOff();
  720.                         brakerunABlock.getSection().setBrakesOn();
  721.                         }
  722.                     }
  723.                 } else {
  724.                     brakerunABlock.getSection().setBrakesOn();
  725.                     brakerunABlock.getSection().setTransportsOff();
  726.                    
  727.                     Train train = brakerunABlock.getSection().getTrainOnSection();
  728.                     if (train.getSpeed() == 0) {
  729.                         brakerunABlock.setState(STATE_BLOCK_WAIT_FOR_CLEAR);
  730.                     }
  731.                 }
  732.                 break;
  733.            
  734.             case STATE_BLOCK_WAIT_FOR_ADVANCE:
  735.                 if (mode == AUTO_MODE) {
  736.                     brakerunABlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  737.                 } else {
  738.                     brakerunABlock.getSection().setTransportsOff();
  739.                     brakerunABlock.getSection().setBrakesOn();
  740.                 }
  741.                 break;
  742.            
  743.             case STATE_BLOCK_LEAVING:
  744.                 brakerunABlock.getSection().setBrakesOff();
  745.                 brakerunABlock.getSection().setTransportsStandardFwdDependingOnBrake();
  746.                 if (brakerunABlock.getNumberOfTrainsOnBlock() == 0) {
  747.                     brakerunABlock.setState(STATE_BLOCK_FREE);
  748.                 }
  749.                 break;
  750.            
  751.             case STATE_BLOCK_WAIT_FOR_CLEAR:
  752.                 if (brakerunABlock.getSection().isTrainBehindBrakeTrigger()) {
  753.                     brakerunABlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  754.                 } else {
  755.                     brakerunABlock.setState(STATE_BLOCK_BEFORE_TRIGGER);
  756.                 }
  757.                 break;
  758.         }
  759.     }
  760.    
  761.     private void processBrakerunBBlock() {
  762.         switch (brakerunBBlock.getState()) {
  763.             case STATE_BLOCK_FREE:
  764.                 brakerunBBlock.getSection().setTransportsOff();
  765.                 brakerunBBlock.getSection().setBrakesOn();
  766.                 break;
  767.            
  768.             case STATE_BLOCK_APPROACHING:
  769.                 if (brakerunBBlock.getSection().isTrainOnSection()) {
  770.                     brakerunBBlock.setState(STATE_BLOCK_BEFORE_TRIGGER);
  771.                 } else {
  772.                     brakerunBBlock.getSection().setBrakesOff();
  773.                     brakerunBBlock.getSection().setTransportsOff();
  774.                 }
  775.                 break;
  776.            
  777.             case STATE_BLOCK_BEFORE_TRIGGER:
  778.                 brakerunBBlock.getSection().setBrakesTrim();
  779.                 brakerunBBlock.getSection().setTransportsStandardFwdDependingOnBrake();
  780.                 if (brakerunBBlock.getSection().isTrainBehindBrakeTrigger()) {
  781.                     brakerunBBlock.setState(STATE_BLOCK_BEHIND_TRIGGER);
  782.                 }
  783.                 break;
  784.            
  785.             case STATE_BLOCK_BEHIND_TRIGGER:   
  786.                 brakerunBBlock.getSection().setTransportsOff();
  787.                 brakerunBBlock.getSection().setBrakesOn();
  788.                 brakerunBBlock.setState(STATE_BLOCK_WAIT_FOR_CLEAR);
  789.                 break;
  790.            
  791.             case STATE_BLOCK_WAIT_FOR_CLEAR:
  792.                 brakerunBBlock.getSection().setBrakesOn();
  793.                 brakerunBBlock.getSection().setTransportsOff();
  794.                 if (canBrakeMoveForward()) {
  795.                     if (mode == MANUAL_BLOCK_MODE) {
  796.                         brakerunBBlock.setState(STATE_BLOCK_WAIT_FOR_ADVANCE);
  797.                     } else {
  798.                         stationExitBlock.setState(STATE_BLOCK_APPROACHING);
  799.                         brakerunBBlock.setState(STATE_BLOCK_LEAVING);
  800.                     }
  801.                 }
  802.                 break;
  803.            
  804.             case STATE_BLOCK_WAIT_FOR_ADVANCE:
  805.                 brakerunBBlock.getSection().setBrakesOn();
  806.                 brakerunBBlock.getSection().setTransportsOff();
  807.                 if (!canBrakeMoveForward()) {
  808.                     brakerunBBlock.setState(STATE_BLOCK_WAIT_FOR_CLEAR);
  809.                 }
  810.                 break;
  811.            
  812.             case STATE_BLOCK_LEAVING:
  813.                 if (brakerunBBlock.getSection().isTrainOnSection()) {
  814.                     brakerunBBlock.getSection().setBrakesOff();
  815.                     brakerunBBlock.getSection().setTransportsStandardFwdDependingOnBrake();
  816.                 } else {
  817.                     brakerunBBlock.getSection().setBrakesOn();
  818.                     brakerunBBlock.getSection().setTransportsOff();
  819.                 }
  820.                
  821.                 if (brakerunBBlock.getNumberOfTrainsOnBlock() == 0) {
  822.                     brakerunBBlock.setState(STATE_BLOCK_FREE);
  823.                 }
  824.                 break;
  825.         }
  826.     }
  827.    
  828.     private void processStorageABlock() {
  829.        
  830.     }
  831.    
  832.     private void processStorageBBlock() {
  833.        
  834.     }
  835.    
  836.     private bool canBrakeMoveForward() {
  837.         return (storageSwitch.getSwitchDirection() == 0) && (stationExitBlock.getState() == STATE_BLOCK_FREE);
  838.     }
  839.    
  840.     private bool canExitMoveBackward() {
  841.         return (storageSwitch.getSwitchDirection() == 1) && (storageABlock.getState() == STATE_BLOCK_FREE);
  842.     }
  843.    
  844.     private bool canStorageMoveForward() {
  845.         return (storageSwitch.getSwitchDirection() == 1) && (stationExitBlock.getState() == STATE_BLOCK_FREE);
  846.     }
  847.    
  848.     public void onTrainEntering(TrackTrigger trigger, Train train) {
  849.         if (trigger == launchOccupiedEnableTrigger) {
  850.             launchOccupied = true;
  851.         } else if (trigger == launchOccupiedDisableTrigger) {
  852.             launchOccupied = false;
  853.         } else if (trigger == zoneAOccupiedTrigger) {
  854.             zoneAOccupied = true;
  855.         } else if (trigger == launchBackwardsTrigger) {
  856.             launchBackwards = true;
  857.         } else if ((trigger == launchBackwardsReadyTrigger) && (launchBackwards)) {
  858.             launchBackwardsReady = true;
  859.         }
  860.     }
  861.    
  862.     public void onTrainLeaving(TrackTrigger trigger, Train train) {
  863.         if (trigger == zoneAClearTrigger) {
  864.             zoneAOccupied = false;
  865.         }
  866.     }
  867. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!