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