sql-edition/servers/Idler.py

   1 #!/usr/bin/env python
   2
   3 import string
   4 from random import random
   5
   6 orderings = None
   7
   8 class Idler:
   9         def __init__(self, v):
  10                 self.v = v
  11
  12         def next(self):
  13                 pass
  14
  15         def reset(self):
  16                 pass
  17
  18 class TrainIdler(Idler):
  19         def __init__(self, v):
  20                 self.idle_state = 0
  21                 self.v = v
  22
  23         def put_shark(self, s, l):
  24                 if self.s[l] == ' ':
  25                         self.s[l] = s
  26                 elif self.s[l] == 'X':
  27                         self.s[l] = '*'
  28                 else:
  29                         self.s[l] = 'X'
  30
  31         def next(self):
  32                 # does the next stage of a dance
  33                 self.s = [' ']*10
  34                 shark1 = self.idle_state % 18
  35                 if shark1 < 9:
  36                         self.put_shark('^', shark1)
  37                 else:
  38                         self.put_shark('^', 18-shark1)
  39
  40                 shark2 = ((self.idle_state+4) % 36)/2
  41                 if shark2 < 9:
  42                         self.put_shark('<', shark2)
  43                 else:
  44                         self.put_shark('<', 18-shark2)
  45
  46                 shark3 = ((self.idle_state+7) % 54)/3
  47                 if shark3 < 9:
  48                         self.put_shark('>', 9-shark3)
  49                 else:
  50                         self.put_shark('>', 9-(18-shark3))
  51
  52                 train1 = ((self.idle_state%(18*36)))
  53                 train1_start = 122
  54                 if train1 > train1_start and train1 < train1_start+(10*2):
  55                         for i in range(5):
  56                                 ptr = i+train1-train1_start-5
  57                                 if ptr >= 0 and ptr < 10: self.s[ptr] = '#'
  58
  59                 train2 = ((self.idle_state%(18*36)))
  60                 train2_start = 400
  61                 if train2 > train2_start and train2 < train2_start+(10*2):
  62                         for i in range(5):
  63                                 ptr = i+train2-train2_start-5
  64                                 if ptr >= 0 and ptr < 10: self.s[9-ptr] = '#'
  65
  66                 train3 = ((self.idle_state%(18*36)))
  67                 train3_start = 230
  68                 if train3 > train3_start and train3 < train3_start+(10*2):
  69                         for i in range(10):
  70                                 ptr = i+train3-train3_start-10
  71                                 if ptr >= 0 and ptr < 10: self.s[ptr] = '-'
  72
  73                 self.v.display(string.join(self.s, ''))
  74                 self.idle_state += 1
  75                 self.idle_state %= 18*36*54
  76
  77         def reset(self):
  78                 self.idle_state = 0
  79
  80 class OrderMaker:
  81         def __init__(self, n=8):
  82                 self.n = n
  83                 self.a = []
  84                 self.u = []
  85                 self.s = []
  86                 for x in range(0,n):
  87                         self.u.append(False)
  88                 self.go()
  89
  90         def go(self):
  91                 from copy import deepcopy
  92                 if len(self.s) == self.n:
  93                         self.a.append(deepcopy(self.s))
  94                 else:
  95                         for x in range(0,self.n):
  96                                 if self.u[x]: continue
  97                                 self.s.append(x)
  98                                 self.u[x] = True
  99                                 self.go()
 100                                 self.u[x] = False
 101                                 self.s.pop()
 102
 103         def order(self):
 104                 return self.a
 105
 106 class GrayIdler(Idler):
 107         def __init__(self, v, one=None, zero=None, reorder=0):
 108                 self.bits = 8
 109                 self.size = 1 << self.bits
 110                 self.i = 0
 111                 self.grayCode = 0
 112                 self.v = v
 113                 self.one = one
 114                 self.zero = zero
 115                 self.reorder = reorder
 116                 global orderings
 117                 if not orderings:
 118                         orderings = OrderMaker().order()
 119
 120         def next(self):
 121                 output = self.do_next_state()
 122                 # does the next stage of a dance
 123                 if self.zero:
 124                         output = string.replace(output, "0", self.zero)
 125                 if self.one:
 126                         output = string.replace(output, "1", self.one)
 127                 if self.reorder:
 128                         global orderings
 129                         newoutput = ""
 130                         for i in range(0,8):
 131                                 newoutput += output[orderings[self.reorder][i]]
 132                         output = newoutput
 133                 self.v.display(" %8.8s " % (output))
 134                 self.i = (self.i + 1) % self.size
 135
 136         def do_next_state(self):
 137                 self.grayCode = self.i ^ (self.i >> 1)
 138                 output = self.dec2bin(self.grayCode)
 139
 140                 return "0"*(self.bits-len(output))+output
 141
 142
 143         def dec2bin(self,num):
 144             """Convert long/integer number to binary string.
 145
 146             E.g. dec2bin(12) ==> '1100'.
 147
 148             from http://starship.python.net/~gherman/playground/decbingray/decbingray.py"""
 149
 150             assert num >= 0, "Decimal number must be >= 0!"
 151
 152             # Gracefully handle degenerate case.
 153             # (Not really needed, but anyway.)
 154             if num == 0:
 155                 return '0'
 156
 157             # Find highest value bit.
 158             val, j = 1L, 1L
 159             while val < num:
 160                 val, j = val*2L, j+1L
 161
 162             # Convert.
 163             bin = ''
 164             i = j - 1
 165             while i + 1L:
 166                 k = pow(2L, i)
 167                 if num >= k:
 168                     bin = bin + '1'
 169                     num = num - k
 170                 else:
 171                     if len(bin) > 0:
 172                         bin = bin + '0'
 173                 i = i - 1L
 174
 175             return bin
 176
 177         def reset(self):
 178                 self.i = 0
 179                 self.grayCode = 0
 180                 if self.reorder:
 181                         self.reorder = int(random()*40319)+1