Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Untitled

By: a guest on Jul 6th, 2012  |  syntax: None  |  size: 3.92 KB  |  hits: 12  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. package com.malkierian.redstonechips.ClockDisplay;
  2.  
  3. import org.bukkit.command.CommandSender;
  4. import org.tal.redstonechips.circuit.Circuit;
  5.  
  6. public class dclock extends Circuit {
  7.         private enum chipMode {
  8.                 hour,
  9.                 minute_double
  10.         }
  11.        
  12.         private chipMode mode;
  13.         @Override
  14.         protected boolean init(CommandSender sender, String[] args) {
  15.                 if(inputs.length < 7 && (inputs.length != 5 && inputs.length != 6))
  16.                 {
  17.                         error(sender, "Not enough inputs!  Hours = 5, minutes = 6.");
  18.                         return false;
  19.                 }
  20.                 else if(inputs.length >= 7)
  21.                 {
  22.                         error(sender, "Too many inputs!  Hours = 5, minutes = 6.");
  23.                         return false;
  24.                 }
  25.                 if(args.length > 0)
  26.                 {
  27.                         error(sender, "ClockDisplay does not take any arguments.");
  28.                         return false;
  29.                 }
  30.                 if(inputs.length == 5)
  31.                 {
  32.                         if(outputs.length != 8)
  33.                         {
  34.                                 error(sender, "Missing outputs for hour mode.  Needs 8.");
  35.                                 return false;
  36.                         }
  37.                         mode = chipMode.hour;
  38.                        
  39.                 }
  40.                 return true;
  41.         }
  42.        
  43.         private boolean bits[];
  44.        
  45.         private int halfday = 12;
  46.  
  47.         @Override
  48.         public void inputChange(int inIdx, boolean state) {
  49.                 if(mode == chipMode.hour)
  50.                 {
  51.                         outputBits.clear();
  52.                         for(int i = 0; i < 5; i++)
  53.                         {
  54.                                 bits[i] = inputBits.get(i);
  55.                         }
  56.                         if(bits[4])
  57.                         {
  58.                                 if(bits[3])
  59.                                 {
  60.                                         sendInt(0, outputs.length, hourIndex[0]);
  61.                                         return;
  62.                                 }
  63.                                 else if(bits[2])
  64.                                 {
  65.                                         if(bits[1])
  66.                                         {
  67.                                                 if(bits[0])
  68.                                                 {
  69.                                                         sendInt(0, outputs.length, hourIndex[6]);
  70.                                                 }
  71.                                                 else
  72.                                                 {
  73.                                                         sendInt(0, outputs.length, hourIndex[5]);
  74.                                                 }
  75.                                         }
  76.                                         else if(bits[0])
  77.                                         {
  78.                                                 sendInt(0, outputs.length, hourIndex[4]);
  79.                                         }
  80.                                         else
  81.                                         {
  82.                                                 sendInt(0, outputs.length, hourIndex[3]);
  83.                                         }
  84.                                 }
  85.                                 else if(bits[1])
  86.                                 {
  87.                                         if(bits[0])
  88.                                         {
  89.                                                 sendInt(0, outputs.length, hourIndex[2]);
  90.                                         }
  91.                                         else
  92.                                         {
  93.                                                 sendInt(0, outputs.length, hourIndex[1]);
  94.                                         }
  95.                                 }
  96.                                 else if(bits[0])
  97.                                 {
  98.                                         sendInt(0, outputs.length, hourIndex[12]);
  99.                                 }
  100.                                 else
  101.                                 {
  102.                                         sendInt(0, outputs.length, hourIndex[11+halfday]);
  103.                                 }
  104.                         }
  105.                         else if(bits[3])
  106.                         {
  107.                                 if(bits[2])
  108.                                 {
  109.                                         if(bits[1])
  110.                                         {
  111.                                                 if(bits[0])
  112.                                                 {
  113.                                                         sendInt(0, outputs.length, hourIndex[10+halfday]);
  114.                                                 }
  115.                                                 else
  116.                                                 {
  117.                                                         sendInt(0, outputs.length, hourIndex[9+halfday]);
  118.                                                 }
  119.                                         }
  120.                                         else if(bits[0])
  121.                                         {
  122.                                                 sendInt(0, outputs.length, hourIndex[8+halfday]);
  123.                                         }
  124.                                         else
  125.                                         {
  126.                                                 sendInt(0, outputs.length, hourIndex[7+halfday]);
  127.                                         }
  128.                                 }
  129.                                 else if(bits[1])
  130.                                 {
  131.                                         if(bits[0])
  132.                                         {
  133.                                                 sendInt(0, outputs.length, hourIndex[6+halfday]);
  134.                                         }
  135.                                         else
  136.                                         {
  137.                                                 sendInt(0, outputs.length, hourIndex[5+halfday]);
  138.                                         }
  139.                                 }
  140.                                 else if(bits[0])
  141.                                 {
  142.                                         sendInt(0, outputs.length, hourIndex[4+halfday]);
  143.                                 }
  144.                                 else
  145.                                 {
  146.                                         sendInt(0, outputs.length, hourIndex[3+halfday]);
  147.                                 }
  148.                         }
  149.                         else if(bits[2])
  150.                         {
  151.                                 if(bits[1])
  152.                                 {
  153.                                         if(bits[0])
  154.                                         {
  155.                                                 sendInt(0, outputs.length, hourIndex[2+halfday]);
  156.                                         }
  157.                                         else
  158.                                         {
  159.                                                 sendInt(0, outputs.length, hourIndex[1+halfday]);
  160.                                         }
  161.                                 }
  162.                                 else if(bits[0])
  163.                                 {
  164.                                         sendInt(0, outputs.length, hourIndex[12+halfday]);
  165.                                 }
  166.                                 else
  167.                                 {
  168.                                         sendInt(0, outputs.length, hourIndex[11]);
  169.                                 }
  170.                         }
  171.                         else if(bits[1])
  172.                         {
  173.                                 if(bits[0])
  174.                                 {
  175.                                         sendInt(0, outputs.length, hourIndex[10]);
  176.                                 }
  177.                                 else
  178.                                 {
  179.                                         sendInt(0, outputs.length, hourIndex[9]);
  180.                                 }
  181.                         }
  182.                         else if(bits[0])
  183.                         {
  184.                                 sendInt(0, outputs.length, hourIndex[8]);
  185.                         }
  186.                         else
  187.                         {
  188.                                 sendInt(0, outputs.length, hourIndex[7]);
  189.                         }
  190.                 }
  191.                
  192.         }
  193.        
  194.         private int hourIndex[] = {
  195.                         0,
  196.                         1,
  197.                         2,
  198.                         4,
  199.                         8,
  200.                         16,
  201.                         32,
  202.                         64+1,
  203.                         64+2,
  204.                         64+4,
  205.                         64+8,
  206.                         64+16,
  207.                         64+32,
  208.                         128+1,
  209.                         128+2,
  210.                         128+4,
  211.                         128+8,
  212.                         128+16,
  213.                         128+32,
  214.                         128+64+1,
  215.                         128+64+2,
  216.                         128+64+4,
  217.                         128+64+8,
  218.                         128+64+16,
  219.                         128+64+32
  220.                        
  221.         };
  222.        
  223. }
create a new version of this paste RAW Paste Data