Author: 4B796C65@gmail.com

CHANGELOG.txt

@@ -1,25 +1,32 @@
-1.1.3
- * Some of the setFont parameters were incorrectly labeled and documented
- * setFont can auto-detect tilesets if the font sizes are in the filenames
- * Added some X11 unicode tilesets, including unifont.
-
-1.1.2
- * Window title now defaults to the running scripts filename
- * Fixed incorrect deltaTime for App.update
- * App will no longer call tdl.flush on its own, you'll need to call this yourself
- * tdl.noise module added
- * clear method now defaults to black on black
-
-1.1.1
- * map submodule added with AStar class and quickFOV function
- * new Typewriter class
- * most console functions can use Python-style negative indexes now
- * new App.runOnce method
- * rectangle geometry is less strict
-
-1.1.0
- * KeyEvent.keyname is now KeyEvent.key
- * MouseButtonEvent.button now behaves like KeyEvent.keyname does
- * event.App class added
- * drawing methods no longer have a default for the character parameter
- * KeyEvent.ctrl is now KeyEvent.control
+ 
+ * Fixed the clear method on Window class
+ * Fixed screenshot function
+ * Fixed some drawing operations with unchanging backgrounds
+ * Instances of Console and Noise can be pickled and copied
+ * Added KeyEvent.keychar
+
+1.1.3
+ * Some of the setFont parameters were incorrectly labeled and documented
+ * setFont can auto-detect tilesets if the font sizes are in the filenames
+ * Added some X11 unicode tilesets, including unifont.
+
+1.1.2
+ * Window title now defaults to the running scripts filename
+ * Fixed incorrect deltaTime for App.update
+ * App will no longer call tdl.flush on its own, you'll need to call this yourself
+ * tdl.noise module added
+ * clear method now defaults to black on black
+
+1.1.1
+ * map submodule added with AStar class and quickFOV function
+ * new Typewriter class
+ * most console functions can use Python-style negative indexes now
+ * new App.runOnce method
+ * rectangle geometry is less strict
+
+1.1.0
+ * KeyEvent.keyname is now KeyEvent.key
+ * MouseButtonEvent.button now behaves like KeyEvent.keyname does
+ * event.App class added
+ * drawing methods no longer have a default for the character parameter
+ * KeyEvent.ctrl is now KeyEvent.control

dev/runRegressionTest.py

@@ -6,29 +6,55 @@
 import time
 import random
 import itertools
+import copy
+import pickle
 import gc
 
 sys.path.insert(0, '..')
 import tdl
 
-ERROR_RANGE = 100 # a number to test out of bound errors
+#ERROR_RANGE = 100 # a number to test out of bound errors
+WIDTH, HEIGHT = 30, 20
+WINWIDTH, WINHEIGHT = 10, 10
+
+DEFAULT_CHAR = (0x20, (0, 0, 0), (0, 0, 0))
 
 class TDLTemplate(unittest.TestCase):
     "Nearly all tests need tdl.init to be called"
 
     @classmethod
     def setUpClass(cls):
         tdl.setFont('../fonts/libtcod/terminal8x8_gs_ro.png')
-        cls.console = tdl.init(30, 20, 'TDL UnitTest', False, renderer='SDL')
+        cls.console = tdl.init(WIDTH, HEIGHT, 'TDL UnitTest', False, renderer='SDL')
+        # make a small window in the corner
+        cls.window = tdl.Window(cls.console, 0, 0, WINWIDTH, WINHEIGHT)
 
     def setUp(self):
+        tdl.setFont('../fonts/libtcod/terminal8x8_gs_ro.png')
+        tdl.event.get()
         self.console.clear()
 
     @classmethod
     def tearDownClass(cls):
         del cls.console
         gc.collect() # make sure console.__del__ is called quickly
 
+    def inWindow(self, x, y):
+        "returns True if this point is in the Window"
+        return 0 <= x < WINWIDTH and 0 <= y < WINHEIGHT
+        
+    def randomizeConsole(self):
+        "Randomize the console returning the random data"
+        noise = [((x, y), self.getRandomCharacter()) for x,y in self.getDrawables()]
+        for (x, y), graphic in noise:
+            self.console.drawChar(x, y, *graphic)
+        return noise # [((x, y), (cg, fg, bg)), ...]
+        
+    def flush(self):
+        'Pump events and refresh screen so show progress'
+        tdl.event.get()
+        tdl.flush()
+        
     def getRandomCharacter(self):
         "returns a tuple with a random character and colors (ch, fg, bg)"
         return (random.getrandbits(8), self.getRandomColor(), self.getRandomColor())
@@ -75,16 +101,34 @@ def getUndrawables(self, console=None):
 class BasicTests(TDLTemplate):
 
     def test_clearConsole(self):
+        self.randomizeConsole()
         _, fg, bg = self.getRandomCharacter()
         ch = 0x20 # space
         self.console.clear(fg, bg)
+        self.flush()
+        for x,y in self.getDrawables():
+            self.assertEqual((ch, fg, bg), self.console.getChar(x, y), 'color should be changed with clear')
+        _, fg2, bg2 = self.getRandomCharacter()
+        self.window.clear(fg2, bg2)
+        self.flush()
+        for x,y in self.getDrawables():
+            if self.inWindow(x, y):
+                self.assertEqual((ch, fg2, bg2), self.console.getChar(x, y), 'color in window should be changed')
+            else:
+                self.assertEqual((ch, fg, bg), self.console.getChar(x, y), 'color outside of window should persist')
+        
+    def test_cloneConsole(self):
+        noiseData = self.randomizeConsole()
+        clone = copy.copy(self.console)
+        for x,y in self.getDrawables():
+            self.assertEqual(self.console.getChar(x, y), clone.getChar(x, y), 'console clone should match root console')
+    
+    def test_pickleConsole(self):
+        noiseData = self.randomizeConsole()
+        pickled = pickle.dumps(self.console)
+        clone = pickle.loads(pickled)
         for x,y in self.getDrawables():
-            self.assertEqual((ch, fg, bg), self.console.getChar(x, y), 'color should be changeable with clear')
-        #fg = (255, 255, 255)
-        #bg = (0, 0, 0)
-        #self.console.clear()
-        #for x,y in self.getDrawables():
-        #    self.assertEqual((ch, fg, bg), self.console.getChar(x, y), 'clear should default to white on black')
+            self.assertEqual(self.console.getChar(x, y), clone.getChar(x, y), 'pickled console should match root console')
 
     def test_changeFonts(self):
         "Fonts are changable on the fly... kind of"
@@ -97,8 +141,8 @@ def test_changeFonts(self):
             for x,y in self.getDrawables():
                 self.console.drawChar(x, y, *self.getRandomCharacter())
             tdl.setTitle(font)
-            tdl.flush()
-            time.sleep(.25)
+            self.flush()
+            time.sleep(.05)
 
 
 class DrawingTests(TDLTemplate):
@@ -111,6 +155,8 @@ def test_drawCharTuples(self):
             record[x,y] = (ch, fg, bg)
             self.console.drawChar(x, y, ch, fg, bg)
             self.assertEqual(record[x,y], self.console.getChar(x, y), 'console data should be overwritten')
+            self.flush() # show progress
+            
         for (x,y), data in record.items():
             self.assertEqual(data, self.console.getChar(x, y), 'drawChar should not overwrite any other tiles')
 
@@ -125,6 +171,7 @@ def test_drawCharWebcolor(self):
             bg = bg[0] << 16 | bg[1] << 8 | bg[2]
             self.console.drawChar(x, y, ch, fg, bg)
             self.assertEqual(record[x,y], self.console.getChar(x, y), 'console data should be overwritten')
+            self.flush() # show progress
         for (x,y), data in record.items():
             self.assertEqual(data, self.console.getChar(x, y), 'drawChar should not overwrite any other tiles')
 
@@ -155,6 +202,7 @@ def test_drawStrArray(self):
                     y += 1
                     if y == height:
                         break # end of console
+            self.flush() # show progress
 
     #@unittest.skipIf(not __debug__, 'python run with optimized flag, skipping an AssertionError test')
     #def test_drawStrErrors(self):
@@ -171,9 +219,10 @@ def test_drawRect(self):
             width, height = self.console.getSize()
             width, height = random.randint(1, width - x), random.randint(1, height - y)
             self.console.drawRect(x, y, width, height, ch, fg, bg)
+            self.flush() # show progress
             for testX,testY in self.getDrawables():
                 if x <= testX < x + width and y <= testY < y + height:
-                    self.assertEqual(self.console.getChar(testX, testY), (ch, fg, bg), 'rectangle are should be overwritten')
+                    self.assertEqual(self.console.getChar(testX, testY), (ch, fg, bg), 'rectangle area should be overwritten')
                 else:
                     self.assertEqual(self.console.getChar(testX, testY), consoleCopy.getChar(testX, testY), 'this area should remain untouched')
 
@@ -185,6 +234,7 @@ def test_drawFrame(self):
             width, height = self.console.getSize()
             width, height = random.randint(1, width - x), random.randint(1, height - y)
             self.console.drawFrame(x, y, width, height, ch, fg, bg)
+            self.flush() # show progress
             for testX,testY in self.getDrawables():
                 if x + 1 <= testX < x + width - 1 and y + 1 <= testY < y + height - 1:
                     self.assertEqual(self.console.getChar(testX, testY), consoleCopy.getChar(testX, testY), 'inner frame should remain untouched')
@@ -204,27 +254,29 @@ def test_drawFrame(self):
     #        with self.assertRaises(AssertionError):
     #            self.console.drawFrame(x, y, width, height, ch, fg, bg)
 
-    @unittest.skip("Need this to be faster before unskipping")
+    #@unittest.skip("Need this to be faster before unskipping")
     def test_scrolling(self):
         """marks a spot and then scrolls the console, checks to make sure no
         other spots are marked, test also knows if it's out of bounds.
         
         This test is a bit slow, it could be made more efficent by marking
         several areas and not clearing the console every loop.
         """
-        for sx, sy in itertools.product(range(-30, 30, 5), range(-20, 20, 5)):
-            self.console.clear()
-            char = self.getRandomCharacter()
-            dx, dy = random.choice(list(self.getDrawables()))
-            self.console.drawChar(dx, dy, *char)
+        scrollTests = set([(0, 0), (WIDTH, HEIGHT)]) # include zero and out of bounds
+        while len(scrollTests) < 5: # add 3 more randoms
+            scrollTests.add((random.randint(-WIDTH, WIDTH),
+                             random.randint(-HEIGHT, HEIGHT)))
+        for sx, sy in scrollTests:
+            noiseData = dict(self.randomizeConsole())
             self.console.scroll(sx, sy)
-            dx += sx # if these go out of bounds then the check will make sure everything is cleared
-            dy += sy
+            self.flush() # show progress
             for x, y in self.getDrawables():
-                if x == dx and y == dy:
-                    self.assertEqual(self.console.getChar(x, y), char, 'marked position should have scrolled here')
+                nX = x - sx
+                nY = y - sy
+                if (nX, nY) in noiseData:
+                    self.assertEqual(self.console.getChar(x, y), noiseData[nX, nY], 'random noise should be scrolled')
                 else:
-                    self.assertEqual(self.console.getChar(x, y), (0x20, (255, 255, 255), (0, 0, 0)), 'every other place should be clear')
+                    self.assertEqual(self.console.getChar(x, y), DEFAULT_CHAR, 'scrolled away positions should be clear')
 
 
 def suite():

examples/eventget.py

@@ -13,7 +13,7 @@
 console = tdl.init(WIDTH, HEIGHT)
 
 # the scrolling text window
-textWindow = tdl.Window(console, 0, 0, WIDTH, HEIGHT-2)
+textWindow = tdl.Window(console, 0, 0, WIDTH, -2)
 
 # slow down the program so that the user can more clearly see the motion events
 tdl.setFPS(24)

setup.py

@@ -1,8 +1,10 @@
 #!/usr/bin/env python
 
-import os.path
-import subprocess
-from distutils.core import setup
+try:
+    # use setuptools or distribute if available
+    from setuptools import setup
+except ImportError:
+    from distutils.core import setup
 
 setup(name='tdl',
       version='1.1.3',

tdl/__init__.py

@@ -547,11 +547,11 @@ def getCover(x, length):
         self.blit(self, x, y, width, height, srcx, srcy)
 
         if uncoverX: # clear sides (0x20 is space)
-            self.drawRect(uncoverX[0], coverY[0], uncoverX[1], coverY[1], 0x20)
+            self.drawRect(uncoverX[0], coverY[0], uncoverX[1], coverY[1], 0x20, 0x000000, 0x000000)
         if uncoverY: # clear top/bottom
-            self.drawRect(coverX[0], uncoverY[0], coverX[1], uncoverY[1], 0x20)
+            self.drawRect(coverX[0], uncoverY[0], coverX[1], uncoverY[1], 0x20, 0x000000, 0x000000)
         if uncoverX and uncoverY: # clear corner
-            self.drawRect(uncoverX[0], uncoverY[0], uncoverX[1], uncoverY[1], 0x20)
+            self.drawRect(uncoverX[0], uncoverY[0], uncoverX[1], uncoverY[1], 0x20, 0x000000, 0x000000)
 
     def getChar(self, x, y):
         """Return the character and colors of a tile as (ch, fg, bg)
@@ -625,6 +625,26 @@ def __del__(self):
         except StandardError:
             pass # I forget why I put this here but I'm to afraid to delete it
 
+    def __copy__(self):
+        # make a new class and blit
+        clone = self.__class__(self.width, self.height)
+        clone.blit(self)
+        return clone
+        
+    def __getstate__(self):
+        # save data from getChar
+        data = [self.getChar(x, y) for x,y in
+                itertools.product(range(self.width), range(self.height))]
+        return self.width, self.height, data
+            
+    def __setstate__(self, state):
+        # make console from __init__ and unpack a getChar array
+        width, height, data = state
+        self.__init__(width, height)
+        for (x, y), graphic in zip(itertools.product(range(width),
+                                                     range(height)), data):
+            self.drawChar(x, y, *graphic)
+            
     def _replace(self, console):
         """Used internally
 
@@ -655,7 +675,7 @@ def clear(self, fgcolor=(0, 0, 0), bgcolor=(0, 0, 0)):
         
                         Must be a 3-item list with integers that range 0-255.
                         
-                        Unlike most other operations you can not use None here.
+                        Unlike most other operations you cannot use None here.
         @type bgcolor: (r, g, b)
         @param bgcolor: Background color.  See fgcolor.
         """
@@ -699,11 +719,12 @@ def _setCharBatch(self, batch, fgcolor, bgcolor, bgblend=1, nullChar=False):
             # buffer values as ctypes objects
             self._typewriter = None # clear the typewriter as colors will be set
             console = self._as_parameter_
-            if not bgcolor:
-                bgblend = 0
             bgblend = ctypes.c_int(bgblend)
 
-            _lib.TCOD_console_set_default_background(console, bgcolor)
+            if not bgcolor:
+                bgblend = 0
+            else:
+                _lib.TCOD_console_set_default_background(console, bgcolor)
             _lib.TCOD_console_set_default_foreground(console, fgcolor)
             _putChar = _lib.TCOD_console_put_char # remove dots and make local
             for (x, y), char in batch:
@@ -792,7 +813,7 @@ def clear(self, fgcolor=(0, 0, 0), bgcolor=(0, 0, 0)):
         """
         assert _verify_colors(fgcolor, bgcolor)
         assert fgcolor and bgcolor, 'Can not use None with clear'
-        self.draw_rect(0, 0, None, None, 0x20, fgcolor, bgcolor)
+        self.drawRect(0, 0, None, None, 0x20, fgcolor, bgcolor)
 
     def _setChar(self, x, y, char=None, fgcolor=None, bgcolor=None, bgblend=1):
         self.parent._setChar((x + self.x), (y + self.y), char, fgcolor, bgcolor, bgblend)
@@ -1234,24 +1255,25 @@ def screenshot(path=None):
     """
     if not _rootinitialized:
         raise TDLError('Initialize first with tdl.init')
-    if isinstance(fileobj, str):
-        _lib.TCOD_sys_save_screenshot(_encodeString(fileobj))
-    elif isinstance(fileobj, file): # save to temp file and copy to file-like obj
-        tmpname = os.tempnam()
-        _lib.TCOD_sys_save_screenshot(_encodeString(tmpname))
-        with tmpname as tmpfile:
-            fileobj.write(tmpfile.read())
-        os.remove(tmpname)
-    elif fileobj is None: # save to screenshot001.png, screenshot002.png, ...
+    if isinstance(path, str):
+        _lib.TCOD_sys_save_screenshot(_encodeString(path))
+    elif path is None: # save to screenshot001.png, screenshot002.png, ...
         filelist = os.listdir('.')
         n = 1
         filename = 'screenshot%.3i.png' % n
         while filename in filelist:
             n += 1
-            filename = 'screenshot%.4i.png' % n
+            filename = 'screenshot%.3i.png' % n
         _lib.TCOD_sys_save_screenshot(_encodeString(filename))
-    else:
-        raise TypeError('fileobj is an invalid type: %s' % type(fileobj))
+    else: # assume file like obj
+        #save to temp file and copy to file-like obj
+        tmpname = os.tempnam()
+        _lib.TCOD_sys_save_screenshot(_encodeString(tmpname))
+        with tmpname as tmpfile:
+            path.write(tmpfile.read())
+        os.remove(tmpname)
+    #else:
+    #    raise TypeError('path is an invalid type: %s' % type(path))
 
 def setFPS(frameRate):
     """Set the maximum frame rate.