Langton’s Ant


A little while ago I came across the topic of Cellular Automata. I was fascinated about the idea that complex (and even Turing-complete) behavior can come from a system that follows a few simple rules.

One of the more simple types of cellular automaton is Langton’s ant. This type seemed like a good choice to start with. I’ve been wanting to get into Python for a while now so I figured this would be a good project to get my feet wet.

Continue reading Langton’s Ant

Creating a chat room


Learning network programming has been on my backburner for quite a while now, so I decided that it was about time I got around to it.

Way back when I made a program called NetChat that was written in, of all things, a language called Blitz Basic, which was a language focused on making games. NetChat was what my friends and I used at school to chat with each other between classrooms (instead of paying attention in class…) It was single threaded and used Blitz Basic’s implementation of networking to communicate. Nonetheless it had support for multiple concurrent users, colors for users and their messages, an admin user, and even the ability for all users to draw on a picture at the same time using colored circles of various sizes.

Unfortunately the source code and program has been lost for years now, which is disappointing because it was probably the most full featured, and definitely most used, program I had made around that time. Since then I’ve been wanting to recreate it in a more common language. This post is about the first steps toward making it, simply figuring out how to send and receive pieces of data through the network.

Continue reading Creating a chat room

Working with a 7-segment display

Recently it was announced that many Radioshack stores are closing due to bankruptcy issues. It turned out to be a good opportunity to pick up some parts and equipment to start messing around with Arduinos. I’ve always kind of wanted to get into Arduinos after taking a class on microcontrollers back in college.

I started out checking out a lot of the sample stuff. The “Blink” sample sketch seems to be the “hello world” for Arduinos. I blinked some LEDs, faded some LEDs, read buttons, made LEDs turn on with buttons, etc.

I picked up a “Basic Electronic Parts Kit” as well, and the 7-segment displays stuck out to me, so I gave them a shot.

Continue reading Working with a 7-segment display

Generating a Dungeon (part 3)

When I last left off I had the rooms (or data equivalent of rooms) created, the last thing that needed to be done was add in cycles so that the dungeon layout is not a tree. That’s what I’ll be tackling in this post.

I’ve updated the generateMap() function and added a call to the new function fixTree() at the end:


void GeneratedMap::fixTree()
//get all dead ends
std::vector<Room*> deadEnds;
for (unsigned int i = 0; i < rooms.size(); i++)
if (rooms[i]->isDeadEnd())
std::random_shuffle(deadEnds.begin(), deadEnds.end());

unsigned int i = 0;
int addedCount = 0;
int cyclesToAdd = (deadEnds.size() * CYCLE_PERCENT) / 100;
//keep adding cycles until the quantity is met or we run out of
//dead ends to try
while (i < deadEnds.size() && addedCount < cyclesToAdd)
Room* de = deadEnds[i++];
std::vector<Room*> adjacentRooms = getAdjacentRooms(de);
if (adjacentRooms.size() <= 0)
std::random_shuffle(adjacentRooms.begin(), adjacentRooms.end());

unsigned int j = 0;
Room* aj = nullptr;
//find first non-connected room
if (!de->areConnected(adjacentRooms[j]))
aj = adjacentRooms[j];
} while (j < adjacentRooms.size() && aj == nullptr);

//if no non-connected room is found try the next dead-end
if (aj == nullptr)

aj->hasSecondEntrance = true;

//rooms are adjacent, but not connected, now we connect them... with
int directionOfOther = de->directionOfOtherRoom(aj);
int miny = 0, minx = 0, shift = 0;
if (directionOfOther == Room::LEFT || directionOfOther == Room::RIGHT)
miny = std::max(de->topLeft.y, aj->topLeft.y);
int maxy = std::min(de->bottomRight.y, aj->bottomRight.y);
int dy = std::abs(maxy - miny);
shift = dy <= 0 ? 0 : rand() % (dy + 1);
else if (directionOfOther == Room::UP || directionOfOther == Room::DOWN)
minx = std::max(de->topLeft.x, aj->topLeft.x);
int maxx = std::min(de->bottomRight.x, aj->bottomRight.x);
int dx = std::abs(maxx - minx);
shift = dx <= 0 ? 0 : rand() % (dx + 1);

switch (directionOfOther)
case Room::LEFT:
aj->startingCell2 = Vector2i(aj->bottomRight.x, miny + shift);
aj->previousCell2 = Vector2i(de->topLeft.x, miny + shift);
case Room::RIGHT:
aj->startingCell2 = Vector2i(aj->topLeft.x, miny + shift);
aj->previousCell2 = Vector2i(de->bottomRight.x, miny + shift);
case Room::UP:
aj->startingCell2 = Vector2i(minx + shift, aj->bottomRight.y);
aj->previousCell2 = Vector2i(minx + shift, de->topLeft.y);
case Room::DOWN:
aj->startingCell2 = Vector2i(minx + shift, aj->topLeft.y);
aj->previousCell2 = Vector2i(minx + shift, de->bottomRight.y);


Continue reading Generating a Dungeon (part 3)