sql-edition/servers/Idler.py

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