sql-edition/servers/Idler.py

   1 #!/usr/bin/env python
   2
   3 import string, time, popen2, os
   4 from random import random
   5 from MessageKeeper import MessageKeeper
   6
   7 orderings = None
   8
   9 IDLER_TEXT_SPEED=1.8
  10
  11 class Idler:
  12         def __init__(self, v):
  13                 self.v = v
  14
  15         def next(self):
  16                 """Displays next stage of the idler"""
  17                 pass
  18
  19         def reset(self):
  20                 """Resets the idler to a known intial state"""
  21                 pass
  22
  23         def finished(self):
  24                 """Returns True if the idler is considered finished"""
  25                 return False
  26
  27         def affinity(self):
  28                 """How much we want this idler to be the next one chosen"""
  29                 return 1
  30
  31 class TrainIdler(Idler):
  32         def __init__(self, v):
  33                 self.idle_state = 0
  34                 self.v = v
  35
  36         def put_shark(self, s, l):
  37                 if self.s[l] == ' ':
  38                         self.s[l] = s
  39                 elif self.s[l] == 'X':
  40                         self.s[l] = '*'
  41                 else:
  42                         self.s[l] = 'X'
  43
  44         def next(self):
  45                 # does the next stage of a dance
  46                 self.s = [' ']*10
  47                 shark1 = self.idle_state % 18
  48                 if shark1 < 9:
  49                         self.put_shark('^', shark1)
  50                 else:
  51                         self.put_shark('^', 18-shark1)
  52
  53                 shark2 = ((self.idle_state+4) % 36)/2
  54                 if shark2 < 9:
  55                         self.put_shark('<', shark2)
  56                 else:
  57                         self.put_shark('<', 18-shark2)
  58
  59                 shark3 = ((self.idle_state+7) % 54)/3
  60                 if shark3 < 9:
  61                         self.put_shark('>', 9-shark3)
  62                 else:
  63                         self.put_shark('>', 9-(18-shark3))
  64
  65                 train1 = ((self.idle_state%(18*36)))
  66                 train1_start = 122
  67                 if train1 > train1_start and train1 < train1_start+(10*2):
  68                         for i in range(5):
  69                                 ptr = i+train1-train1_start-5
  70                                 if ptr >= 0 and ptr < 10: self.s[ptr] = '#'
  71
  72                 train2 = ((self.idle_state%(18*36)))
  73                 train2_start = 400
  74                 if train2 > train2_start and train2 < train2_start+(10*2):
  75                         for i in range(5):
  76                                 ptr = i+train2-train2_start-5
  77                                 if ptr >= 0 and ptr < 10: self.s[9-ptr] = '#'
  78
  79                 train3 = ((self.idle_state%(18*36)))
  80                 train3_start = 230
  81                 if train3 > train3_start and train3 < train3_start+(10*2):
  82                         for i in range(10):
  83                                 ptr = i+train3-train3_start-10
  84                                 if ptr >= 0 and ptr < 10: self.s[ptr] = '-'
  85
  86                 self.v.display(string.join(self.s, ''))
  87                 self.idle_state += 1
  88                 self.idle_state %= 18*36*54
  89
  90         def reset(self):
  91                 self.idle_state = 0
  92
  93 class OrderMaker:
  94         def __init__(self, n=8):
  95                 self.n = n
  96                 self.a = []
  97                 self.u = []
  98                 self.s = []
  99                 for x in range(0,n):
 100                         self.u.append(False)
 101                 self.go()
 102
 103         def go(self):
 104                 from copy import deepcopy
 105                 if len(self.s) == self.n:
 106                         self.a.append(deepcopy(self.s))
 107                 else:
 108                         for x in range(0,self.n):
 109                                 if self.u[x]: continue
 110                                 self.s.append(x)
 111                                 self.u[x] = True
 112                                 self.go()
 113                                 self.u[x] = False
 114                                 self.s.pop()
 115
 116         def order(self):
 117                 return self.a
 118
 119 class GrayIdler(Idler):
 120         def __init__(self, v, one=None, zero=None, reorder=0):
 121                 self.bits = 8
 122                 self.size = 1 << self.bits
 123                 self.i = 0
 124                 self.grayCode = 0
 125                 self.v = v
 126                 self.one = one
 127                 self.zero = zero
 128                 self.reorder = reorder
 129                 global orderings
 130                 if not orderings:
 131                         orderings = OrderMaker().order()
 132
 133         def next(self):
 134                 output = self.do_next_state()
 135                 # does the next stage of a dance
 136                 if self.zero:
 137                         output = string.replace(output, "0", self.zero)
 138                 if self.one:
 139                         output = string.replace(output, "1", self.one)
 140                 if self.reorder:
 141                         global orderings
 142                         newoutput = ""
 143                         for i in range(0,8):
 144                                 newoutput += output[orderings[self.reorder][i]]
 145                         output = newoutput
 146                 self.v.display(" %8.8s " % (output))
 147                 self.i = (self.i + 1) % self.size
 148
 149         def do_next_state(self):
 150                 self.grayCode = self.i ^ (self.i >> 1)
 151                 output = self.dec2bin(self.grayCode)
 152
 153                 return "0"*(self.bits-len(output))+output
 154
 155
 156         def dec2bin(self,num):
 157             """Convert long/integer number to binary string.
 158
 159             E.g. dec2bin(12) ==> '1100'.
 160
 161             from http://starship.python.net/~gherman/playground/decbingray/decbingray.py"""
 162
 163             assert num >= 0, "Decimal number must be >= 0!"
 164
 165             # Gracefully handle degenerate case.
 166             # (Not really needed, but anyway.)
 167             if num == 0:
 168                 return '0'
 169
 170             # Find highest value bit.
 171             val, j = 1L, 1L
 172             while val < num:
 173                 val, j = val*2L, j+1L
 174
 175             # Convert.
 176             bin = ''
 177             i = j - 1
 178             while i + 1L:
 179                 k = pow(2L, i)
 180                 if num >= k:
 181                     bin = bin + '1'
 182                     num = num - k
 183                 else:
 184                     if len(bin) > 0:
 185                         bin = bin + '0'
 186                 i = i - 1L
 187
 188             return bin
 189
 190         def reset(self):
 191                 self.i = 0
 192                 self.grayCode = 0
 193                 if self.reorder:
 194                         self.reorder = int(random()*40319)+1
 195
 196
 197 class StringIdler(Idler):
 198         def __init__(self, v, text="Hello Cruel World!  ",repeat=True):
 199                 self.v = v
 200                 self.mk = MessageKeeper(v)
 201                 self.text = self.clean_text(text) + "          "
 202
 203                 msg = [("",False, None),(self.text, repeat, IDLER_TEXT_SPEED)]
 204                 self.mk.set_messages(msg)
 205
 206         def clean_text(self, text):
 207                 # nothing like a bit of good clean text :)
 208                 valid = string.digits \
 209                         + string.letters \
 210                         + string.punctuation \
 211                         + " "
 212                 # uppercase it
 213                 text = string.upper(text)
 214                 clean = ""
 215                 for char in text:
 216                         if char in valid:
 217                                 clean = clean + char
 218                         else:
 219                                 clean = clean + " "
 220                 return clean
 221
 222         def next(self):
 223                 self.mk.update_display()
 224
 225         def finished(self):
 226                 return self.mk.done()
 227
 228 class ClockIdler(Idler):
 229         def __init__(self, v):
 230                 self.v = v
 231                 self.last = None
 232
 233         def next(self):
 234                 output = time.strftime("%H:%M:%S")
 235                 if output != self.last:
 236                         self.v.display(" %8.8s " % (output))
 237                         self.last = output
 238
 239         def affinity(self):
 240                 return 3
 241
 242 class FortuneIdler(StringIdler):
 243         def __init__(self, v):
 244                 fortune = "/usr/games/fortune"
 245                 text = "I broke my wookie...."
 246                 if os.access(fortune,os.F_OK|os.X_OK):
 247                         (stdout, stdin) = popen2.popen2(fortune)
 248                         text = string.join(stdout.readlines())
 249                         stdout.close()
 250                         stdin.close()
 251                 StringIdler.__init__(self, v, text,repeat=False)
 252
 253         def affinity(self):
 254                 return 20
 255
 256 class PipeIdler(StringIdler):
 257         def __init__(self, v, command, args):
 258                 text = "I ate my cookie...."
 259                 if os.access(command,os.F_OK|os.X_OK):
 260                         (stdout, stdin) = popen2.popen2(command+' '+args)
 261                         text = string.join(stdout.readlines())
 262                         stdout.close()
 263                         stdin.close()
 264                 StringIdler.__init__(self, v, text,repeat=False)
 265
 266         def affinity(self):
 267                 return 20
 268
 269 class FileIdler(StringIdler):
 270         def __init__(self, v, thefile=None, repeat=False):
 271                 text = "I broke my wookie...."
 272
 273                 if file and os.access(thefile,os.F_OK|os.R_OK):
 274                         f = file(thefile,'r')
 275                         text = string.join(f.readlines())
 276                         f.close()
 277                 StringIdler.__init__(self, v, text,repeat=repeat)
 278
 279         def affinity(self):
 280                 return 8