Added wxFileHistory demo

[wxWidgets.git] / demos / life / game.cpp

diff --git a/demos/life/game.cpp b/demos/life/game.cpp
index f4fe8774d09e0f3da86ee160621d7ee3303f9290..a356f550a1216aadd9fb87ff76c80caef2dc811c 100644 (file)
--- a/demos/life/game.cpp
+++ b/demos/life/game.cpp
@@ -9,6 +9,10 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

+#ifdef __WIN16__
+#error "Sorry, Life! will not work in 16-bit Windows"
+#endif
+

 // ==========================================================================
 // headers, declarations, constants
 // ==========================================================================
 // ==========================================================================
 // headers, declarations, constants
 // ==========================================================================


@@ -17,26 +21,40 @@
     #pragma implementation "game.h"
 #endif
 
     #pragma implementation "game.h"
 #endif
 

+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+#include "wx/wx.h"
+#endif
+

 #include "wx/log.h"
 #include "wx/log.h"

+#include "wx/module.h"

 #include "game.h"
 
 #include "game.h"
 

-#include <stdlib.h>           // for abort

 #include <string.h>           // for memset
 
 
 #include <string.h>           // for memset
 
 

-#define ARRAYSIZE  1024      // size of the static arrays for BeginFind & co.
+#define ARRAYSIZE  1024       // static array for BeginFind & co.

 #define ALLOCBOXES 16         // number of cellboxes to alloc at once
 #define ALLOCBOXES 16         // number of cellboxes to alloc at once

+#define MAXDEAD    8          // tics before removing cellbox from list
+

 
 // ==========================================================================
 // CellBox
 // ==========================================================================
 
 #define HASH(x, y) (((x >> 3) & 0x7f) << 7) + ((y >> 3) & 0x7f)
 
 // ==========================================================================
 // CellBox
 // ==========================================================================
 
 #define HASH(x, y) (((x >> 3) & 0x7f) << 7) + ((y >> 3) & 0x7f)

-#define HASHSIZE   32768
-#define MAXDEAD    8

 
 

+#define HASHSIZE   32768      // hash table size (do not change!)
+#define CELLBOX    8          // cells in a cellbox (do not change!)

 
 

-class CellBox
+
+class LifeCellBox

 {
 public:
     // members
 {
 public:
     // members


@@ -44,21 +62,21 @@ public:
     inline bool SetCell(int dx, int dy, bool alive);
 
     // attributes
     inline bool SetCell(int dx, int dy, bool alive);
 
     // attributes

-    wxInt32   m_x, m_y;                     // position in universe
-    wxUint32  m_live1, m_live2;             // alive cells (1 bit per cell)
-    wxUint32  m_old1, m_old2;               // old values for m_live1, 2
-    wxUint32  m_on[8];                      // neighbouring info
-    wxUint32  m_dead;                       // been dead for n generations
-    CellBox  *m_up, *m_dn, *m_lf, *m_rt;    // neighbour CellBoxes
-    CellBox  *m_prev, *m_next;              // in linked list
-    CellBox  *m_hprev, *m_hnext;            // in hash table
+    wxInt32       m_x, m_y;                     // position in universe
+    wxUint32      m_live1, m_live2;             // alive cells (1 bit per cell)
+    wxUint32      m_old1, m_old2;               // old values for m_live1, 2
+    wxUint32      m_on[8];                      // neighbouring info
+    wxUint32      m_dead;                       // been dead for n generations
+    LifeCellBox  *m_up, *m_dn, *m_lf, *m_rt;    // neighbour CellBoxes
+    LifeCellBox  *m_prev, *m_next;              // in linked list
+    LifeCellBox  *m_hprev, *m_hnext;            // in hash table

 };
 
 
 // IsAlive:
 //  Returns whether cell dx, dy in this box is alive
 //
 };
 
 
 // IsAlive:
 //  Returns whether cell dx, dy in this box is alive
 //

-bool CellBox::IsAlive(int dx, int dy) const
+bool LifeCellBox::IsAlive(int dx, int dy) const

 {
     if (dy > 3)
         return (m_live2 & 1 << ((dy - 4) * 8 + dx));
 {
     if (dy > 3)
         return (m_live2 & 1 << ((dy - 4) * 8 + dx));


@@ -70,7 +88,7 @@ bool CellBox::IsAlive(int dx, int dy) const
 //  Sets cell dx, dy in this box to 'alive', returns TRUE if
 //  the previous value was different, FALSE if it was the same.
 //
 //  Sets cell dx, dy in this box to 'alive', returns TRUE if
 //  the previous value was different, FALSE if it was the same.
 //

-bool CellBox::SetCell(int dx, int dy, bool alive)
+bool LifeCellBox::SetCell(int dx, int dy, bool alive)

 {
     if (IsAlive(dx, dy) != alive)
     {
 {
     if (IsAlive(dx, dy) != alive)
     {


@@ -99,17 +117,24 @@ bool CellBox::SetCell(int dx, int dy, bool alive)
 
 Life::Life()
 {
 
 Life::Life()
 {

-    m_numcells  = 0;
-    m_boxes     = new CellBox *[HASHSIZE];
-    m_head      = NULL;
-    m_available = NULL;
+    // pattern description
+    m_name        = _("");
+    m_rules       = _("");
+    m_description = _("");
+
+    // pattern data
+    m_numcells    = 0;
+    m_boxes       = new LifeCellBox *[HASHSIZE];
+    m_head        = NULL;
+    m_available   = NULL;

     for (int i = 0; i < HASHSIZE; i++)
         m_boxes[i] = NULL;
 
     for (int i = 0; i < HASHSIZE; i++)
         m_boxes[i] = NULL;
 

-    m_cells     = new Cell[ARRAYSIZE];
-    m_ncells    = 0;
-    m_findmore  = FALSE;
-    m_changed   = FALSE;
+    // state vars for BeginFind & FindMore
+    m_cells       = new LifeCell[ARRAYSIZE];
+    m_ncells      = 0;
+    m_findmore    = FALSE;
+    m_changed     = FALSE;

 }
 
 Life::~Life()
 }
 
 Life::~Life()


@@ -125,9 +150,7 @@ Life::~Life()
 //
 void Life::Clear()
 {
 //
 void Life::Clear()
 {

-    CellBox *c, *nc;
-
-    m_numcells = 0;
+    LifeCellBox *c, *nc;

 
     // clear the hash table pointers
     for (int i = 0; i < HASHSIZE; i++)
 
     // clear the hash table pointers
     for (int i = 0; i < HASHSIZE; i++)


@@ -152,6 +175,12 @@ void Life::Clear()
         c = nc;
     }
     m_available = NULL;
         c = nc;
     }
     m_available = NULL;

+
+    // reset state
+    m_name        = _("");
+    m_rules       = _("");
+    m_description = _("");
+    m_numcells    = 0;

 }
 
 // --------------------------------------------------------------------------
 }
 
 // --------------------------------------------------------------------------


@@ -163,7 +192,7 @@ void Life::Clear()
 //
 bool Life::IsAlive(wxInt32 x, wxInt32 y)
 {
 //
 bool Life::IsAlive(wxInt32 x, wxInt32 y)
 {

-    CellBox *c = LinkBox(x, y, FALSE);
+    LifeCellBox *c = LinkBox(x, y, FALSE);

 
     return (c && c->IsAlive( x - c->m_x, y - c->m_y ));
 }
 
     return (c && c->IsAlive( x - c->m_x, y - c->m_y ));
 }


@@ -173,7 +202,7 @@ bool Life::IsAlive(wxInt32 x, wxInt32 y)
 //
 void Life::SetCell(wxInt32 x, wxInt32 y, bool alive)
 {
 //
 void Life::SetCell(wxInt32 x, wxInt32 y, bool alive)
 {

-    CellBox *c  = LinkBox(x, y);
+    LifeCellBox *c  = LinkBox(x, y);

     wxUint32 dx = x - c->m_x;
     wxUint32 dy = y - c->m_y;
 
     wxUint32 dx = x - c->m_x;
     wxUint32 dy = y - c->m_y;
 


@@ -186,19 +215,38 @@ void Life::SetCell(wxInt32 x, wxInt32 y, bool alive)
     }
 }
 
     }
 }
 

-void Life::SetShape(const LifeShape& shape)
+void Life::SetPattern(const LifePattern& pattern)

 {
 {

-    char *p = shape.m_data;
-
-    int i0 = -(shape.m_width / 2);
-    int j0 = -(shape.m_height / 2);
-    int i1 = i0 + shape.m_width - 1;
-    int j1 = j0 + shape.m_height - 1;
+    wxArrayString data = pattern.m_shape;
+    wxString line;
+    long x = 0,
+         y = 0;

 
     Clear();
 
     Clear();

-    for (int j = j0; j <= j1; j++)
-        for (int i = i0; i <= i1; i++)
-            SetCell(i, j, *(p++) == '*');
+    for (size_t n = 0; n < data.GetCount(); n++)
+    {
+        line = data[n];
+
+        if ( (line.GetChar(0) != wxT('*')) &&
+             (line.GetChar(0) != wxT('.')) )
+        {
+            // assume that it is a digit or a minus sign
+            line.BeforeFirst(wxT(' ')).ToLong(&x);
+            line.AfterFirst(wxT(' ')).ToLong(&y);
+        }
+        else
+        {
+            // pattern data
+            for (size_t k = 0; k < line.Len(); k++)
+                SetCell(x + k, y, line.GetChar(k) == wxT('*'));
+
+            y++;
+        }
+    }
+
+    m_name = pattern.m_name;
+    m_rules = pattern.m_rules;
+    m_description = pattern.m_description;

 }
 
 // --------------------------------------------------------------------------
 }
 
 // --------------------------------------------------------------------------


@@ -206,18 +254,18 @@ void Life::SetShape(const LifeShape& shape)
 // --------------------------------------------------------------------------
 
 // CreateBox:
 // --------------------------------------------------------------------------
 
 // CreateBox:

-//  Creates a new box in x, y, either taking it from the list
+//  Creates a box in x, y, either taking it from the list

 //  of available boxes, or allocating a new one.
 //
 //  of available boxes, or allocating a new one.
 //

-CellBox* Life::CreateBox(wxInt32 x, wxInt32 y, wxUint32 hv)
+LifeCellBox* Life::CreateBox(wxInt32 x, wxInt32 y, wxUint32 hv)

 {
 {

-    CellBox *c;
+    LifeCellBox *c;

 
     // if there are no available boxes, alloc a few more
     if (!m_available)
         for (int i = 1; i <= ALLOCBOXES; i++)
         {
 
     // if there are no available boxes, alloc a few more
     if (!m_available)
         for (int i = 1; i <= ALLOCBOXES; i++)
         {

-            c = new CellBox();
+            c = new LifeCellBox();

 
             if (!c)
             {
 
             if (!c)
             {


@@ -229,10 +277,7 @@ CellBox* Life::CreateBox(wxInt32 x, wxInt32 y, wxUint32 hv)
                 // gracefully.
                 wxLogFatalError(_("Out of memory! Aborting..."));
 
                 // gracefully.
                 wxLogFatalError(_("Out of memory! Aborting..."));
 

-                // the above call should abort, but it doesn't :-?
-                abort();
-
-                break;
+                // NOTREACHED

             }
 
             c->m_next = m_available;
             }
 
             c->m_next = m_available;


@@ -244,7 +289,7 @@ CellBox* Life::CreateBox(wxInt32 x, wxInt32 y, wxUint32 hv)
     m_available = c->m_next;
 
     // reset everything
     m_available = c->m_next;
 
     // reset everything

-    memset((void *) c, 0, sizeof(CellBox));
+    memset((void *) c, 0, sizeof(LifeCellBox));

     c->m_x = x;
     c->m_y = y;
 
     c->m_x = x;
     c->m_y = y;
 


@@ -263,13 +308,13 @@ CellBox* Life::CreateBox(wxInt32 x, wxInt32 y, wxUint32 hv)
 
 // LinkBox:
 //  Returns a pointer to the box (x, y); if it didn't exist yet,
 
 // LinkBox:
 //  Returns a pointer to the box (x, y); if it didn't exist yet,

-//  it returns NULL or creates a new one, depending on the 'create'
-//  parameter.
+//  it returns NULL or creates a new one, depending on the value
+//  of the 'create' parameter.

 //
 //

-CellBox* Life::LinkBox(wxInt32 x, wxInt32 y, bool create)
+LifeCellBox* Life::LinkBox(wxInt32 x, wxInt32 y, bool create)

 {
     wxUint32 hv;
 {
     wxUint32 hv;

-    CellBox *c;
+    LifeCellBox *c;

 
     x &= 0xfffffff8;
     y &= 0xfffffff8;
 
     x &= 0xfffffff8;
     y &= 0xfffffff8;


@@ -280,14 +325,14 @@ CellBox* Life::LinkBox(wxInt32 x, wxInt32 y, bool create)
         if ((c->m_x == x) && (c->m_y == y)) return c;
 
     // if not found, and (create == TRUE), create a new one
         if ((c->m_x == x) && (c->m_y == y)) return c;
 
     // if not found, and (create == TRUE), create a new one

-    return create? CreateBox(x, y, hv) : NULL;
+    return create? CreateBox(x, y, hv) : (LifeCellBox*) NULL;

 }
 
 // KillBox:
 //  Removes this box from the list and the hash table and
 //  puts it in the list of available boxes.
 //
 }
 
 // KillBox:
 //  Removes this box from the list and the hash table and
 //  puts it in the list of available boxes.
 //

-void Life::KillBox(CellBox *c)
+void Life::KillBox(LifeCellBox *c)

 {
     wxUint32 hv = HASH(c->m_x, c->m_y);
 
 {
     wxUint32 hv = HASH(c->m_x, c->m_y);
 


@@ -317,74 +362,173 @@ void Life::KillBox(CellBox *c)
 }
 
 // --------------------------------------------------------------------------
 }
 
 // --------------------------------------------------------------------------

-// FindMore & co.
+// Navigation

 // --------------------------------------------------------------------------
 
 // --------------------------------------------------------------------------
 

-// Post eight cells to the cell arrays (changed cells only)
-void Life::DoLine(wxInt32 i, wxInt32 j, wxUint32 live, wxUint32 old)
+LifeCell Life::FindCenter()

 {
 {

-    wxUint32 diff = (live ^ old) & 0x000000ff;
-
-    if (!diff) return;
+    double sx, sy;
+    int n;
+    sx = 0.0;
+    sy = 0.0;
+    n = 0;
+
+    LifeCellBox *c;
+    for (c = m_head; c; c = c->m_next)
+        if (!c->m_dead)
+        {
+            sx += c->m_x;
+            sy += c->m_y;
+            n++;
+        }

 
 

-    for (wxInt32 k = 8; k; k--, i++)
+    if (n > 0)

     {
     {

-        if (diff & 0x01)
+        sx = (sx / n) + CELLBOX / 2;
+        sy = (sy / n) + CELLBOX / 2;
+    }
+
+    LifeCell cell;
+    cell.i = (wxInt32) sx;
+    cell.j = (wxInt32) sy;
+    return cell;
+}
+
+LifeCell Life::FindNorth()
+{
+    wxInt32 x = 0, y = 0;
+    bool first = TRUE;
+
+    LifeCellBox *c;
+    for (c = m_head; c; c = c->m_next)
+        if (!c->m_dead && ((first) || (c->m_y < y)))

         {
         {

-            m_cells[m_ncells].i = i;
-            m_cells[m_ncells].j = j;
-            m_ncells++;
+            x = c->m_x;
+            y = c->m_y;
+            first = FALSE;

         }
         }

-        diff >>= 1;
-        live >>= 1;
-    }
+    
+    LifeCell cell;
+    cell.i = first? 0 : x + CELLBOX / 2;
+    cell.j = first? 0 : y + CELLBOX / 2;
+    return cell;
+}
+
+LifeCell Life::FindSouth()
+{
+    wxInt32 x = 0, y = 0;
+    bool first = TRUE;
+
+    LifeCellBox *c;
+    for (c = m_head; c; c = c->m_next)
+        if (!c->m_dead && ((first) || (c->m_y > y)))
+        {
+            x = c->m_x;
+            y = c->m_y;
+            first = FALSE;
+        }
+    
+    LifeCell cell;
+    cell.i = first? 0 : x + CELLBOX / 2;
+    cell.j = first? 0 : y + CELLBOX / 2;
+    return cell;

 }
 
 }
 

-// Post eight cells to the cell arrays (alive cells only)
-void Life::DoLine(wxInt32 i, wxInt32 j, wxUint32 live)
+LifeCell Life::FindWest()
+{
+    wxInt32 x = 0, y = 0;
+    bool first = TRUE;
+
+    LifeCellBox *c;
+    for (c = m_head; c; c = c->m_next)
+        if (!c->m_dead && ((first) || (c->m_x < x)))
+        {
+            x = c->m_x;
+            y = c->m_y;
+            first = FALSE;
+        }
+    
+    LifeCell cell;
+    cell.i = first? 0 : x + CELLBOX / 2;
+    cell.j = first? 0 : y + CELLBOX / 2;
+    return cell;
+}
+
+LifeCell Life::FindEast()
+{
+    wxInt32 x = 0, y = 0;
+    bool first = TRUE;
+
+    LifeCellBox *c;
+    for (c = m_head; c; c = c->m_next)
+        if (!c->m_dead && ((first) || (c->m_x > x)))
+        {
+            x = c->m_x;
+            y = c->m_y;
+            first = FALSE;
+        }
+    
+    LifeCell cell;
+    cell.i = first? 0 : x + CELLBOX / 2;
+    cell.j = first? 0 : y + CELLBOX / 2;
+    return cell;
+}
+
+// --------------------------------------------------------------------------
+// FindMore & co.
+// --------------------------------------------------------------------------
+
+// DoLine:
+//  Post eight cells to the cell arrays - leave out the fourth
+//  argument (or pass 0, the default value) to post alive cells
+//  only, else it will post cells which have changed.
+//
+void Life::DoLine(wxInt32 x, wxInt32 y, wxUint32 live, wxUint32 old)

 {
 {

-    if (! (live & 0x000000ff)) return;
+    wxUint32 diff = (live ^ old) & 0xff;
+
+    if (!diff) return;

 
 

-    for (wxInt32 k = 8; k; k--, i++)
+    for (wxInt32 k = 8; k; k--, x++)

     {
     {

-        if (live & 0x01)
+        if (diff & 0x01)

         {
         {

-            m_cells[m_ncells].i = i;
-            m_cells[m_ncells].j = j;
+            m_cells[m_ncells].i = x;
+            m_cells[m_ncells].j = y;

             m_ncells++;
         }
             m_ncells++;
         }

-        live >>= 1;
+        diff >>= 1;

     }
 }
 
     }
 }
 

-void Life::BeginFind(wxInt32 i0, wxInt32 j0, wxInt32 i1, wxInt32 j1, bool changed)
+void Life::BeginFind(wxInt32 x0, wxInt32 y0, wxInt32 x1, wxInt32 y1, bool changed)

 {
     // TODO: optimize for the case where the maximum number of
     // cellboxes that fit in the specified viewport is smaller
     // than the current total of boxes; iterating over the list
     // should then be faster than searching in the hash table.
 
 {
     // TODO: optimize for the case where the maximum number of
     // cellboxes that fit in the specified viewport is smaller
     // than the current total of boxes; iterating over the list
     // should then be faster than searching in the hash table.
 

-    m_i0 = m_i = i0 & 0xfffffff8;
-    m_j0 = m_j = j0 & 0xfffffff8;
-    m_i1 = (i1 + 7) & 0xfffffff8;
-    m_j1 = (j1 + 7) & 0xfffffff8;
+    m_x0 = m_x = x0 & 0xfffffff8;
+    m_y0 = m_y = y0 & 0xfffffff8;
+    m_x1 = (x1 + 7) & 0xfffffff8;
+    m_y1 = (y1 + 7) & 0xfffffff8;

 
     m_findmore = TRUE;
     m_changed = changed;
 }
 
 
     m_findmore = TRUE;
     m_changed = changed;
 }
 

-bool Life::FindMore(Cell *cells[], size_t *ncells)
+bool Life::FindMore(LifeCell *cells[], size_t *ncells)

 {
 {

-    CellBox *c;
+    LifeCellBox *c;

     *cells = m_cells;
     m_ncells = 0;
 
     if (m_changed)
     {
     *cells = m_cells;
     m_ncells = 0;
 
     if (m_changed)
     {

-        for ( ; m_j <= m_j1; m_j += 8, m_i = m_i0)
-            for ( ; m_i <= m_i1; m_i += 8)
+        for ( ; m_y <= m_y1; m_y += 8, m_x = m_x0)
+            for ( ; m_x <= m_x1; m_x += 8)

             {
             {

-                if ((c = LinkBox(m_i, m_j, FALSE)) == NULL)
+                if ((c = LinkBox(m_x, m_y, FALSE)) == NULL)

                     continue;
 
                 // check whether there is enough space left in the array
                     continue;
 
                 // check whether there is enough space left in the array


@@ -394,22 +538,22 @@ bool Life::FindMore(Cell *cells[], size_t *ncells)
                     return FALSE;
                 }
 
                     return FALSE;
                 }
 

-                DoLine(m_i, m_j    , c->m_live1,       c->m_old1      );
-                DoLine(m_i, m_j + 1, c->m_live1 >> 8,  c->m_old1 >> 8 );
-                DoLine(m_i, m_j + 2, c->m_live1 >> 16, c->m_old1 >> 16);
-                DoLine(m_i, m_j + 3, c->m_live1 >> 24, c->m_old1 >> 24);
-                DoLine(m_i, m_j + 4, c->m_live2,       c->m_old2      );
-                DoLine(m_i, m_j + 5, c->m_live2 >> 8,  c->m_old2 >> 8 );
-                DoLine(m_i, m_j + 6, c->m_live2 >> 16, c->m_old2 >> 16);
-                DoLine(m_i, m_j + 7, c->m_live2 >> 24, c->m_old2 >> 24);
+                DoLine(m_x, m_y    , c->m_live1,       c->m_old1      );
+                DoLine(m_x, m_y + 1, c->m_live1 >> 8,  c->m_old1 >> 8 );
+                DoLine(m_x, m_y + 2, c->m_live1 >> 16, c->m_old1 >> 16);
+                DoLine(m_x, m_y + 3, c->m_live1 >> 24, c->m_old1 >> 24);
+                DoLine(m_x, m_y + 4, c->m_live2,       c->m_old2      );
+                DoLine(m_x, m_y + 5, c->m_live2 >> 8,  c->m_old2 >> 8 );
+                DoLine(m_x, m_y + 6, c->m_live2 >> 16, c->m_old2 >> 16);
+                DoLine(m_x, m_y + 7, c->m_live2 >> 24, c->m_old2 >> 24);

             }
     }
     else
     {
             }
     }
     else
     {

-        for ( ; m_j <= m_j1; m_j += 8, m_i = m_i0)
-            for ( ; m_i <= m_i1; m_i += 8)
+        for ( ; m_y <= m_y1; m_y += 8, m_x = m_x0)
+            for ( ; m_x <= m_x1; m_x += 8)

             {
             {

-                if ((c = LinkBox(m_i, m_j, FALSE)) == NULL)
+                if ((c = LinkBox(m_x, m_y, FALSE)) == NULL)

                     continue;
 
                 // check whether there is enough space left in the array
                     continue;
 
                 // check whether there is enough space left in the array


@@ -419,14 +563,14 @@ bool Life::FindMore(Cell *cells[], size_t *ncells)
                     return FALSE;
                 }
 
                     return FALSE;
                 }
 

-                DoLine(m_i, m_j    , c->m_live1      );
-                DoLine(m_i, m_j + 1, c->m_live1 >> 8 );
-                DoLine(m_i, m_j + 2, c->m_live1 >> 16);
-                DoLine(m_i, m_j + 3, c->m_live1 >> 24);
-                DoLine(m_i, m_j + 4, c->m_live2      );
-                DoLine(m_i, m_j + 5, c->m_live2 >> 8 );
-                DoLine(m_i, m_j + 6, c->m_live2 >> 16);
-                DoLine(m_i, m_j + 7, c->m_live2 >> 24);
+                DoLine(m_x, m_y    , c->m_live1      );
+                DoLine(m_x, m_y + 1, c->m_live1 >> 8 );
+                DoLine(m_x, m_y + 2, c->m_live1 >> 16);
+                DoLine(m_x, m_y + 3, c->m_live1 >> 24);
+                DoLine(m_x, m_y + 4, c->m_live2      );
+                DoLine(m_x, m_y + 5, c->m_live2 >> 8 );
+                DoLine(m_x, m_y + 6, c->m_live2 >> 16);
+                DoLine(m_x, m_y + 7, c->m_live2 >> 24);

             }
     }
 
             }
     }
 


@@ -439,6 +583,7 @@ bool Life::FindMore(Cell *cells[], size_t *ncells)
 // Evolution engine
 // --------------------------------------------------------------------------
 
 // Evolution engine
 // --------------------------------------------------------------------------
 

+extern unsigned char *g_tab;

 extern int g_tab1[];
 extern int g_tab2[];
 
 extern int g_tab1[];
 extern int g_tab2[];
 


@@ -447,7 +592,7 @@ extern int g_tab2[];
 //
 bool Life::NextTic()
 {
 //
 bool Life::NextTic()
 {

-    CellBox  *c, *up, *dn, *lf, *rt;
+    LifeCellBox  *c, *up, *dn, *lf, *rt;

     wxUint32 t1, t2, t3, t4;
     bool     changed = FALSE;
 
     wxUint32 t1, t2, t3, t4;
     bool     changed = FALSE;
 


@@ -690,87 +835,68 @@ bool Life::NextTic()
     // Stage 2:
     // Stabilize
     //
     // Stage 2:
     // Stabilize
     //

-    // WARNING: to be optimized and unrolled soon.
-    //

     c = m_head;
 
     while (c)
     {
     c = m_head;
 
     while (c)
     {

-        t1 = c->m_live1;
-        c->m_old1 = t1;
+        t1 = 0;

         t2 = 0;
         t2 = 0;

-        int i;
-        for (i = 0; i <= 3; i++)
-        {
-            t3 = c->m_on[i];
-            if (!t3)
-            {
-                t1 >>= 8;
-                t2 >>= 8;
-                continue;
-            }
-
-            for (int j = 0; j < 8; j++)
-            {
-                t2 >>= 1;
-                t4 = t3 & 0x0000000f;
-
-                if ((t4 == 3) || ((t4 == 2) && (t1 & 0x00000001)))
-                {
-                    t2 |= 0x80000000;
-                    m_numcells++;
-                }

 
 

-                t3 >>= 4;
-                t1 >>= 1;
-            }
-            c->m_on[i] = 0;
-        }
-        c->m_live1 = t2;
+        t3 = c->m_live1;
+        c->m_old1 = t3;
+
+        t4 = c->m_on[0];
+        t1 |= g_tab[ ((t4 & 0x0000ffff) << 4 ) + ((t3      ) & 0xf) ];
+        t1 |= g_tab[ ((t4 & 0xffff0000) >> 12) + ((t3 >> 4 ) & 0xf) ] << 4;
+        t4 = c->m_on[1];
+        t1 |= g_tab[ ((t4 & 0x0000ffff) << 4 ) + ((t3 >> 8 ) & 0xf) ] << 8;
+        t1 |= g_tab[ ((t4 & 0xffff0000) >> 12) + ((t3 >> 12) & 0xf) ] << 12;
+        t4 = c->m_on[2];
+        t1 |= g_tab[ ((t4 & 0x0000ffff) << 4 ) + ((t3 >> 16) & 0xf) ] << 16;
+        t1 |= g_tab[ ((t4 & 0xffff0000) >> 12) + ((t3 >> 20) & 0xf) ] << 20;
+        t4 = c->m_on[3];
+        t1 |= g_tab[ ((t4 & 0x0000ffff) << 4 ) + ((t3 >> 24) & 0xf) ] << 24;
+        t1 |= g_tab[ ((t4 & 0xffff0000) >> 12) + ((t3 >> 28) & 0xf) ] << 28;
+
+        t3 = c->m_live2;
+        c->m_old2 = t3;
+
+        t4 = c->m_on[4];
+        t2 |= g_tab[ ((t4 & 0x0000ffff) << 4 ) + ((t3      ) & 0xf) ];
+        t2 |= g_tab[ ((t4 & 0xffff0000) >> 12) + ((t3 >> 4 ) & 0xf) ] << 4;
+        t4 = c->m_on[5];
+        t2 |= g_tab[ ((t4 & 0x0000ffff) << 4 ) + ((t3 >> 8 ) & 0xf) ] << 8;
+        t2 |= g_tab[ ((t4 & 0xffff0000) >> 12) + ((t3 >> 12) & 0xf) ] << 12;
+        t4 = c->m_on[6];
+        t2 |= g_tab[ ((t4 & 0x0000ffff) << 4 ) + ((t3 >> 16) & 0xf) ] << 16;
+        t2 |= g_tab[ ((t4 & 0xffff0000) >> 12) + ((t3 >> 20) & 0xf) ] << 20;
+        t4 = c->m_on[7];
+        t2 |= g_tab[ ((t4 & 0x0000ffff) << 4 ) + ((t3 >> 24) & 0xf) ] << 24;
+        t2 |= g_tab[ ((t4 & 0xffff0000) >> 12) + ((t3 >> 28) & 0xf) ] << 28;
+
+        c->m_on[0] = c->m_on[1] = c->m_on[2] = c->m_on[3] = 
+        c->m_on[4] = c->m_on[5] = c->m_on[6] = c->m_on[7] = 0;
+        c->m_live1 = t1;
+        c->m_live2 = t2;

 
 

-        t1 = c->m_live2;
-        c->m_old2 = t1;
-        t2 = 0;
-        for (i = 4; i <= 7; i++)
+        // count alive cells (TODO: find a better way to do this)
+        for (int i = 0; i < 32; i++)

         {
         {

-            t3 = c->m_on[i];
-            if (!t3)
-            {
-                t1 >>= 8;
-                t2 >>= 8;
-                continue;
-            }
-
-            for (int j = 0; j < 8; j++)
-            {
-                t2 >>= 1;
-                t4 = t3 & 0x0000000f;
-
-                if ((t4 == 3) || ((t4 == 2) && (t1 & 0x00000001)))
-                {
-                    t2 |= 0x80000000;
-                    m_numcells++;
-                }
-
-                t3 >>= 4;
-                t1 >>= 1;
-            }
-            c->m_on[i] = 0;
+            if (t1 & (1 << i)) m_numcells++;
+            if (t2 & (1 << i)) m_numcells++;

         }
         }

-        c->m_live2 = t2;

 
 

-        // keep track of changes
-        changed |= ((c->m_live1 ^ c->m_old1) || (c->m_live2 ^ c->m_old2));
+        changed |= ((t1 ^ c->m_old1) || (t2 ^ c->m_old2));

 
         // mark, and discard if necessary, dead boxes
 
         // mark, and discard if necessary, dead boxes

-        if (c->m_live1 || c->m_live2)
+        if (t1 || t2)

         {
             c->m_dead = 0;
             c = c->m_next;
         }
         else
         {
         {
             c->m_dead = 0;
             c = c->m_next;
         }
         else
         {

-            CellBox *aux = c->m_next;
+            LifeCellBox *aux = c->m_next;

             if (c->m_dead++ > MAXDEAD)
                KillBox(c);
 
             if (c->m_dead++ > MAXDEAD)
                KillBox(c);
 


@@ -781,9 +907,67 @@ bool Life::NextTic()
     return changed;
 }
 
     return changed;
 }
 

-// --------------------------------------------------------------------------
-// Lookup tables - these will be generated on-the-fly soon.
-// --------------------------------------------------------------------------
+// ==========================================================================
+// LifeModule
+// ==========================================================================
+
+// A module to pregenerate lookup tables without having to do it
+// from the application.
+
+class LifeModule: public wxModule
+{
+DECLARE_DYNAMIC_CLASS(LifeModule)
+
+public:
+    LifeModule() {};
+    bool OnInit();
+    void OnExit();
+};
+
+IMPLEMENT_DYNAMIC_CLASS(LifeModule, wxModule)
+
+bool LifeModule::OnInit()
+{
+    // see below
+    g_tab = new unsigned char [0xfffff];
+
+    if (!g_tab) return FALSE;
+
+    for (wxUint32 i = 0; i < 0xfffff; i++)
+    {
+        wxUint32 val  = i >> 4;
+        wxUint32 old  = i & 0x0000f;
+        wxUint32 live = 0;
+
+        for (int j = 0; j < 4; j++)
+        {
+            live >>= 1;
+
+            if (((val & 0xf) == 3) || (((val & 0xf) == 2) && (old & 0x1)))
+                live |= 0x8;
+
+            old >>= 1;
+            val >>= 4;
+        }
+
+        g_tab[i] = (unsigned char) live;
+    }
+
+    return TRUE;
+}
+
+void LifeModule::OnExit()
+{
+    delete [] g_tab;
+}
+
+
+// This table converts from number of neighbors (like in on[]) to
+// bits, for a set of four cells. It takes as index a five-digit
+// hexadecimal value (0xNNNNB) where Ns hold number of neighbors
+// for each cell and B holds their previous state.
+//
+unsigned char *g_tab;

 
 // This table converts from bits (like in live1, live2) to number
 // of neighbors for each cell in the upper or lower row.
 
 // This table converts from bits (like in live1, live2) to number
 // of neighbors for each cell in the upper or lower row.


@@ -941,7 +1125,7 @@ int g_tab1[]=
     0x11112110,
     0x11112121,
     0x11112221,
     0x11112110,
     0x11112121,
     0x11112221,

-    0x11112232,
+    0x11112232,                        

     0x11122100,
     0x11122111,
     0x11122211,
     0x11122100,
     0x11122111,
     0x11122211,