Coding4Fun : events

April Fools' Day Application

Coding4Fun — Fri, 30 Mar 2007 04:03:22 GMT

	In this article, Brian Peek builds an application that will annoy your friends for April Fools' Day!
Brian Peek ASPSOFT, Inc. Difficulty: Easy Time Required: Less than 1 hour Cost: Free Software: Visual Basic or Visual C# Express Editions Hardware: None Download: Download

Introduction

You may recall my previous Halloween article which involved dripping animated blood down a victim's screen. For April Fools' Day, I wrote an application that uses the same basic framework, and provides an equal amount of annoyance for the intended victim.

This time around, the application will lay in wait until the assigned time and then run one of two (or both!) effects: desktop zoom in/out and desktop rotate.

Some of this article will be a bit of a rehash from the previous article, but for the sake of being complete, I will be describing the duplicated portions here.

The Form

We will be creating a full-screen, always-on-top, transparent form that will overlay the entire screen. This will be our display surface for the animation.

The form can be created as described by modifying the following properties:

BackColor – Fuchsia

FormBorderStyle – None

DoubleBuffered – True

Text - <empty string>

WindowState – Normal

ShowInTaskbar – False

TransparencyKey – Fuchsia

TopMost - True

Multiple Monitors

One feature I did not implement in the previous Halloween application was support for systems with multiple monitors. This application will attempt to support a basic multi-mon configuration. When the animation starts, the application must cover the entire display area across all monitors.

One can get information about every monitor attached to a system by using the Screen.AllScreens property. So, to find the maximum "viewport" of the system, the application enumerates all monitors and finds the maximum width/height:

// full width/height of all monitors combined
private Rectangle fullSize;

for(int i = 0; i < Screen.AllScreens.Length; i++)
{
    // find a rectangle that will encompass all monitors on the system
    // (assuming the primary monitor is on the left/top!)
    if(Screen.AllScreens[i].Bounds.Left < fullSize.Left)
        fullSize.X = Screen.AllScreens[i].Bounds.Left;
    if(Screen.AllScreens[i].Bounds.Right > fullSize.Right)
        fullSize.Width = Screen.AllScreens[i].Bounds.Right;
    if(Screen.AllScreens[i].Bounds.Top < fullSize.Top)
        fullSize.Y = Screen.AllScreens[i].Bounds.Top;
    if(Screen.AllScreens[i].Bounds.Bottom > fullSize.Bottom)
        fullSize.Height = Screen.AllScreens[i].Bounds.Bottom;
}

' full width/height of all monitors combined
Private fullSize As Rectangle

For i As Integer = 0 To Screen.AllScreens.Length - 1
    ' find a rectangle that will encompass all monitors on the system
    ' (assuming the primary monitor is on the left/top!)
    If Screen.AllScreens(i).Bounds.Left < fullSize.Left Then
        fullSize.X = Screen.AllScreens(i).Bounds.Left
    End If
    If Screen.AllScreens(i).Bounds.Right > fullSize.Right Then
        fullSize.Width = Screen.AllScreens(i).Bounds.Right
    End If
    If Screen.AllScreens(i).Bounds.Top < fullSize.Top Then
        fullSize.Y = Screen.AllScreens(i).Bounds.Top
    End If
    If Screen.AllScreens(i).Bounds.Bottom > fullSize.Bottom Then
        fullSize.Height = Screen.AllScreens(i).Bounds.Bottom
    End If
Next i

Screen Capture

When the animation starts, a screen capture of each monitor is taken and stored in an array. The animation acts upon these images to produce the rotating and zooming effect. Taking a full screen capture in .NET is quite easy:

// an array of bitmaps, one per monitor on the system
private Bitmap[] screenBitmap;

for(int i = 0; i < Screen.AllScreens.Length; i++)
{
    // grab the size of the current monitor
    Rectangle region = Screen.AllScreens[i].Bounds;

    // create a bitmap of that size
    screenBitmap[i] = new Bitmap(region.Width, region.Height, 
                        PixelFormat.Format32bppArgb);

    // copy the current screen image to the bitmap for the current monitor
    Graphics bitmapGraphics = Graphics.FromImage(screenBitmap[i]);
    bitmapGraphics.CopyFromScreen(region.Left, region.Top, 0, 0, region.Size);
}

' an array of bitmaps, one per monitor on the system
Private screenBitmap As Bitmap()

For i As Integer = 0 To Screen.AllScreens.Length - 1
    ' grab the size of the current monitor
    Dim region As Rectangle = Screen.AllScreens(i).Bounds

    ' create a bitmap of that size
    screenBitmap(i) = New Bitmap(region.Width, region.Height,
                        PixelFormat.Format32bppArgb)

    ' copy the current screen image to the bitmap for the current monitor
    Dim bitmapGraphics As Graphics = Graphics.FromImage(screenBitmap(i))
    bitmapGraphics.CopyFromScreen(region.Left, region.Top, 0, 0, region.Size)
Next i

Drawing

In creating this application, I decided to stay entirely within the framework so deployment would be as simple as copying a single executable to your victim’s machine. Therefore, I decided to use standard GDI+ calls for drawing, instead of Managed DirectX or some other method.

Drawing is done through the use of a timer. The timer ticks once very 100ms and calls the Invalidate method on the form. When invalidated, the form calls its OnPaint handler, which is overridden.

The application currently supports two effects: zooming the desktop into and out of the screen, and rotation. Both effects are obtained using standard GDI+ drawing calls in .NET.

Two dimensional transforms can be easily done using methods from the System.Drawing.Drawing2D namespace. Rotation can be handled using the Rotate and RotateAt methods, and scaling can be done using the Scale method. The effects for this application will be done on a per-monitor basis using the screen captures taken with the above code:

// rotation angle
private float angle = 0.0f;

// scale indexer
private float scaleIndex = 0.0f;

// black background
this.BackColor = Color.Black;

// for each monitor, draw the effect
for(int i = 0; i < screenBitmap.Length; i++)
{
    // grab the size of the current monitor
    Rectangle region = Screen.AllScreens[i].Bounds;

    if(screenBitmap[i] != null)
    {
        Matrix m = new Matrix();

        // rotate the bitmap about the center
        if(Properties.Settings.Default.Rotate)
            m.RotateAt(angle, new Point((Screen.AllScreens[i].Bounds.Width / 2), (Screen.AllScreens[i].Bounds.Height / 2)));

        // scale the image based on the absolute value of cos (gives us a nice in/out effect with minimal effort
        if(Properties.Settings.Default.Zoom)
        {
            scale = Math.Abs((float)Math.Cos(scaleIndex));
            m.Scale(scale, scale);
        }

        // center the image no matter what its size is
        m.Translate(Screen.AllScreens[i].Bounds.Left + (Screen.AllScreens[i].Bounds.Width * (1.0f - scale)/2), Screen.AllScreens[i].Bounds.Top + (Screen.AllScreens[i].Bounds.Height * (1.0f - scale)/2), MatrixOrder.Append);

        // assign our transformation matrix
        e.Graphics.Transform = m;

        // draw it
        e.Graphics.DrawImage(screenBitmap[i], 0, 0);

        // increment our values
        if(Properties.Settings.Default.Zoom)
            scaleIndex += 0.07f;

        if(Properties.Settings.Default.Rotate)
            angle += 2.0f;
    }
}

' rotation angle
Private angle As Single = 0.0f

' scale indexer
Private scaleIndex As Single = 0.0

' black background
Me.BackColor = Color.Black

' for each monitor, draw the effect
For i As Integer = 0 To screenBitmap.Length - 1
    ' grab the size of the current monitor
    Dim region As Rectangle = Screen.AllScreens(i).Bounds

    If Not screenBitmap(i) Is Nothing Then
        Dim m As Matrix = New Matrix()

        ' rotate the bitmap about the center
        If My.Settings.Default.Rotate Then
            m.RotateAt(angle, New Point((Screen.AllScreens(i).Bounds.Width / 2), (Screen.AllScreens(i).Bounds.Height / 2)))
        End If

        ' scale the image based on the absolute value of cos (gives us a nice in/out effect with minimal effort
        If My.Settings.Default.Zoom Then
            scale = Math.Abs(CSng(Math.Cos(scaleIndex)))
            m.Scale(scale, scale)
        End If

        ' center the image no matter what its size is
        m.Translate(Screen.AllScreens(i).Bounds.Left + (Screen.AllScreens(i).Bounds.Width * (1.0f - scale)/2), Screen.AllScreens(i).Bounds.Top + (Screen.AllScreens(i).Bounds.Height * (1.0f - scale)/2), MatrixOrder.Append)

        ' assign our transformation matrix
        e.Graphics.Transform = m

        ' draw it
        e.Graphics.DrawImage(screenBitmap(i), 0, 0)

        ' increment our values
        If My.Settings.Default.Zoom Then
            scaleIndex += 0.07f
        End If

        If My.Settings.Default.Rotate Then
            angle += 2.0f
        End If
    End If
Next i

The code above starts out by setting the background of the window to black. Then for each monitor, an affect is applied. If rotation is enabled, the bitmap is rotated by an ever-increasing angle parameter about the screen's center point. If scaling is enabled, the image is scaled based on the absolute value of the cosine of an ever increasing value, starting at 0. As you may recall from high-school trig, cos(0) = 1. Starting here, will start our scaling factor at 1, which will provide no change. By increasing the value passed to the cos method, we will get decreasing values to 0 after which we will get values which are negative. By taking the absolute value of these numbers, we get a series of decreasing/increasing numbers between 0 and 1.

With the scale and rotation worked out, the images are then translated to the center of the screen before being drawn, which is necessary due to the scaling procedure.

The final calculated matrix is passed to the Graphics.Transform property and the resulting image is finally drawn to the screen, after which the scale and rotation factors are incremented.

The Scheduler

These settings are saved using the Settings object of the project. This way, the user can put the application in the startup group, or create a registry key to load it on startup, so if the PC is rebooted before the desired time is reached, the application will restart and wait for the time to occur.

Settings can be added by right-clicking the project in the Solution Explorer and choosing Properties. Select the Settings tab and a new value can be entered. The one for this application looks like the following:

Now, on application startup, the application’s Settings can be checked to determine if the configuration dialog needs to be shown, or just wait for the time specified.

When the application is started, a scheduler timer is created which ticks every minute. The Tick method for this timer looks at the current time, and if it is greater than or equal to the specified time, it will disable the scheduler timer, maximize the hidden window, take the screen captures, and start the animation timer, which will automatically start the animation.

// called once per minute to check whether it's time to run the show
private void tmrScheduler_Tick(object sender, EventArgs e)
{
    // if the current time is greater than the time set by the user
    if(DateTime.Now >= Properties.Settings.Default.Time)
    {
        for(int i = 0; i < Screen.AllScreens.Length; i++)
        {
            // grab the size of the current monitor
            Rectangle region = Screen.AllScreens[i].Bounds;

            // create a bitmap of that size
            screenBitmap[i] = new Bitmap(region.Width, region.Height, PixelFormat.Format32bppArgb);

            // copy the current screen image to the bitmap for the current monitor
            Graphics bitmapGraphics = Graphics.FromImage(screenBitmap[i]);
            bitmapGraphics.CopyFromScreen(region.Left, region.Top, 0, 0, region.Size);
        }

        // bring up the window
        this.WindowState = FormWindowState.Normal;

        // cover all monitors with one gigantic window
        this.Location = new Point(fullSize.Left, fullSize.Top);
        this.Size = new Size(fullSize.Width, fullSize.Height);

        // disable this timer
        tmrScheduler.Enabled = false;

        // enable the animation timer
        tmrAnim.Enabled = true;

        // bring it to the top
        this.BringToFront();
    }
}

' called once per minute to check whether it's time to run the show
Private Sub tmrScheduler_Tick(ByVal sender As Object, ByVal e As EventArgs) Handles tmrScheduler.Tick
    ' if the current time is greater than the time set by the user
    If DateTime.Now >= My.Settings.Default.Time Then
        For i As Integer = 0 To Screen.AllScreens.Length - 1
            ' grab the size of the current monitor
            Dim region As Rectangle = Screen.AllScreens(i).Bounds

            ' create a bitmap of that size
            screenBitmap(i) = New Bitmap(region.Width, region.Height, PixelFormat.Format32bppArgb)

            ' copy the current screen image to the bitmap for the current monitor
            Dim bitmapGraphics As Graphics = Graphics.FromImage(screenBitmap(i))
            bitmapGraphics.CopyFromScreen(region.Left, region.Top, 0, 0, region.Size)
        Next i

        ' bring up the window
        Me.WindowState = FormWindowState.Normal

        ' cover all monitors with one gigantic window
        Me.Location = New Point(fullSize.Left, fullSize.Top)
        Me.Size = New Size(fullSize.Width, fullSize.Height)

        ' disable this timer
        tmrScheduler.Enabled = False

        ' enable the animation timer
        tmrAnim.Enabled = True

        ' bring it to the top
        Me.BringToFront()
    End If
End Sub

Deployment

When you are ready to annoy your friend, simply copy the AprilFoolsDay.exe and AprilFoolsDay.exe.config files to his or her PC. (You may want to enlist someone as the “lookout” so you don’t get caught while doing so!) Create a shortcut to it in the Startup program group, or set it up to run via the registry using the following key for the logged in user:

HKCU\Software\Microsoft\Windows\CurrentVersion\Run

Simply create a new string key with any Name, and a Data value of the path to the executable.

Next, start the application once on their PC to setup the date and time for the show to begin. Once that is done, the application will remain running in the background. If the PC is restarted, and the application is setup to run at startup as described above, it will start silently and remain running, waiting for the date and time specified.

If you need to reset the configuration for any reason, simply run the application from the command line with the -config switch and it will display the configuration dialog box again.

Summary

And there we have it. A very simple application requiring very little code that will elicit quite a reaction from your victim. The code can be very easily modified to include new features and different animation effects. Give it a try!

Thanks

A special thank you to Mark Zaugg for testing on a few machines outside my house to ensure things were working as expected.

Bio

Though Brian is a recognized .NET expert with over 6 years experience developing .NET solutions, and over 9 years of professional experience architecting and developing solutions using Microsoft technologies and platforms, he has been "coding for fun" for as long as he can remember. Outside the world of .NET and business applications, Brian enjoys developing both hardware and software projects in the areas of gaming, robotics, and whatever else strikes his fancy for the next ten minutes. He rarely passes up an opportunity to dive into a C/C++ or assembly language project. You can reach Brian via his blog at http://www.brianpeek.com/.

Have You Been Naughty or Nice?

Coding4Fun — Thu, 14 Dec 2006 21:47:56 GMT

	Is Santa paying you a visit this year? Find out how naughty or nice you are based on what you say on your blog or personal web site!
Arian Kulp Arian Kulp's Blog Difficulty: Intermediate Time Required: 1-3 hours Cost: Free Software: Visual Basic or Visual C# Express Editions Hardware: Download: Sample Code

He's making a list and checking it twice,
Gonna find out who's naughty and nice,
Santa Claus is coming to town.

Did this song creep you out as a kid? It did me! Now that you're all grown up (well, some of us anyway!) you may think that it doesn't apply to you anymore. Do you really want to take that chance though? I didn't think so! This article helps to evaluate your level of naughtiness/niceness based on your blog (or other personal web site).

Read the article for some background information, then explore the code yourself. This application uses the BackgroundWorker, WebClient, and works with regular expressions with the Regex object. In order to open the project, you will need Visual Studio Express Editions (either C# or Visual Basic) or higher. You can download the Express editions for free from here.

Background

An ancient Chinese proverb states that "The entries in your blog reveal your inner self." Even though I just made that up, it's no less true. Are you grumpy, happy, hopeful, crazy? Chances are it's obvious from your blog posts. This application will take a URL, scan it for a list of "naughty" and "nice" words, and come up with a score of niceness. But beware: pages linked from the given URL will also be scanned and taken into account.

(click image to zoom)

Downloading the URL

So the first step is to download the given URL. This can be accomplished by opening a socket, issuing an HTTP GET request, and reading back the resulting stream of bytes one at a time. On the other hand, it can also be performed in two lines of code using the System.Net.WebClient object. For me, the choice was simple. The WebClient has a number of methods to download a file synchronously or asynchronously, either as a string, a byte array, or directly to a file. Once the object is instantiated, a single line of code does the actual work. It's so easy, you'll be adding URL download functionality into every application before you know it!

NOTE: You must specify a complete URL, that is, beginning with HTTP. You won't get an error otherwise, it just won't appear to work right.

Visual Basic

Dim wc As WebClient = New WebClient
body = wc.DownloadString(url)

Visual C#

WebClient wc = new WebClient();
body = wc.DownloadString(url);

Searching for Patterns

Once you have the contents of the URL in a string, you can anything with it as with any other string. Perform IndexOf searches, save it to a database, or apply regular expressions. This is the use of interest for this application. Regular expression support is found in the System.Text.RegularExpressions namespace with the Regex object. Using the Regex object is pretty easy, but coming up with the expression itself can be a challenge.

If you haven't used regular expressions before, you may want to take a few minutes to read about them. I good place to start is the MSDN reference page, .NET Framework Regular Expressions. Unfortunately, regular expressions aren't very intuitive at first (or ever for some people!). Creating your own expression can be difficult, but you can often find pre-built ones online. Note that regular expressions are used in conjunction with string verification, formatting, searching, and replacing. This application will use three different expressions. One will be used to search for "nice" keywords, another for "naughty" keywords. The third expression will locate hyperlinks based on the href attribute of the a element found in HTML.

Creating a Regex object incurs some overhead, not only from object creation, but also from parsing the expression. To minimize this, all three Regex objects are created when the application starts up.

Visual Basic

Dim REGEX_NICE_WORDS As String = "love|great|good|rocks|awesome|nice"
Dim REGEX_NAUGHTY_WORDS As String = "damn|sucks|hate|stupid|dumb|bad"
Dim REGEX_HYPERLINKS As String = "href\s*=\s*(?:\""""(?<1>[^""""]*)""""|(?<1>\S+))"

Private urlRegex, niceregex, naughtyregex As Regex

Visual C#

private const string REGEX_NICE_WORDS = "love|great|good|rocks|awesome|nice";
private const string REGEX_NAUGHTY_WORDS = "damn|sucks|hate|stupid|dumb|bad";
private const string REGEX_HYPERLINKS = "href\\s*=\\s*(?:\"\"(?<1>[^\"\"]*)\"\"|(?<1>\\S+))";

private Regex niceRegex, naughtyRegex, urlRegex;

The basic flow will be: search for nice words, search for naughty keywords, search for hyperlinks, repeat the nice/naughty search for each linked page. Linked pages are not scanned for additional links to avoid overload. As it is, some sites already take a full minute to process! The process of downloading a page then performing the searches is contained in the DetermineScore method.

In order to actually perform the search, invoke the Matches method. This returns a MatchCollection object for iteration. There's no need to iterate the actual words found, so the Count property is sufficient:

Visual Basic

niceCount = niceregex.Matches(body).Count
naughtyCount = naughtyregex.Matches(body).Count

Visual C#

niceCount = niceRegex.Matches(body).Count;
naughtyCount = naughtyRegex.Matches(body).Count;

Another one line of code performing lots of work! If you needed the information, you could then use the returned MatchCollection to determine specifically which words were returned, along with much other information about each match. The expression for nice and naughty words is simple: the vertical pipe (bar) acts like an OR Boolean operator. In other words, the regular expression parser will scan the entire input string (the downloaded HTML) and add a Match object each time one of the words is found.

Looking a Level Deeper

After analyzing the given URL, it's time to take a look at linked pages. After all, the types of sites you link to also say something about how naughty or nice you probably are! That third regular expression is much more complex than the first two. Showing it again, we have:

href\s*=\s*(?:""(?<1>[^""]*)""|(?<1>\S+))

This is complicated a bit by the way that strings must be escaped in Visual C# and Visual Basic. In both languages, you can't just have quotes within a quoted string (you'll notice that this expression is slight different in the VB and C# code samples above). In C#, you precede the double quote with a backslash (\"). If you actually need a backslash, you need to double that as well (\\). In Visual Basic, you double the doublequote (""). What does this mess mean? Well, suffice to say that is looking for the href attribute, and the quotes and brackets after it. Unfortunately, the resulting match is always more than we actually want. For example, a link to my site would be returned as:

href="http://ariankulp.com/rss.aspx"

It also returns returns relative links, CSS/RSS links, and others that aren't all that interesting. It's easy to filter out the relative links by checking to see if each match begins with href="http. The CSS/RSS links, if using an absolute host, are more complicated, so I don't filter them out. For each valid match found, I call the DetermineScore method to count up naughty and nice words. Note that the scores on linked pages are cut in half. More weight is given to your own site!

Putting it All Together

Performing all of the URL downloads and pattern matching takes some time. A site with many links can really slow things down. When you click the button to start things off, any work that you perform will occur on the user interface thread. All of a sudden, the application is unresponsive. The solution to this is to run the analyzing in a separate, background thread. The BackgroundWorker object makes this easy. When you invoke the RunWorkerAsync method, the DoWork event fires on a different thread. The event handler then makes the necessary calls to download and analyze the given URL and discovered URL's.

As each link is analyzed, progress is reported by raising the ProgressChanged event. This is responsible for adding the links, along with naughty/nice count, to the ListView control.

Visual Basic

Dim ls As LinkScore = CType(e.UserState, LinkScore)
Dim lvi As ListViewItem = scoresListView.Items.Add(ls.Url)

lvi.SubItems.AddRange(New String() {ls.Good.ToString, ls.Bad.ToString})

overallProgressBar.Style = ProgressBarStyle.Blocks
overallProgressBar.Value = e.ProgressPercentage

Visual C#

LinkScore ls = e.UserState as LinkScore;

ListViewItem lvi = scoresListView.Items.Add(ls.Url);
lvi.SubItems.AddRange(
    new string[] { ls.Good.ToString(), ls.Bad.ToString() });

overallProgressBar.Style = ProgressBarStyle.Blocks;
overallProgressBar.Value = e.ProgressPercentage;

Clicking Cancel calls the CancelAsync method. The worker thread periodically checks the CancellationRequested flag to exit early if necessary. While the initial link is being downloaded, a ProgressBar control goes into marquee mode (think Knight Rider!). It changes to a standard progress bar as discovered links are analyzed. Finally, the RunWorkerCompleted event fires when everything is done (based on the DoWork event handler completing). This updates the progress percentage, enables the Cancel button, and hides the progress bar.

Next Steps

The application isn't all that useful, but it's fun! It could easily be extended to perform different actions on discovered pages, or simply to search for different keywords. Several enhancements that would be fairly easy would be:

Add a checkbox to prevent linked pages from being counted. This would speed things up.
Add an options page to edit naughty/nice keywords and tweak other settings.
Restrict the number of links to follow. If the given URL has links to 200 other pages, it may never finish!
Better filtering of links. As I mentioned, resources like RSS or CSS don't need to be downloaded. Links on the same site may not be needed either. Checking for the same base URL would be a pretty easy addition.
Create multiple worker threads to share the load of analyzing linked pages. This is a good scenario for parallelizing.

Conclusion

I hope that you had fun with this application. It was fun coming up with a naughty-or-nice formula! I struggled a bit with the best balance. It's not perfect, but it works pretty well. If you have a better approach, by all means tweak it. Best of all, have fun!

Get started by downloading Visual Studio Express and download the sample code today.

Arian Kulp is an independent software developer and writer working in the Midwest. He has been coding since the fifth grade on various platforms, and also enjoys photography, nature, and spending time with his family. Arian can be reached through his web site at http://www.ariankulp.com.

Holiday Gift Guide 2006

Coding4Fun — Thu, 07 Dec 2006 08:09:00 GMT

Tired of giving socks every year to your favorite engineer or technology elitist? Coding4Fun has come up with a holiday gift guide of items that are sure to make them glee with joy. We’ve cranked up the geek-factor and have tried to come up with the biggest list of programmable presents on the Web! If you like the guide, Digg Us.

Do you know of a programmable present that wasn’t listed here? Email us and we’ll get it added to our list.

The holiday guide is broken down into 5 sections. Programmable Hardware and Gadgets, Programmable Robots, Programmable Games, Cool Software Tools, and Top 10 Presents for Developers

Programmable Hardware and Gadgets

Enjoy tinkering? Think that the orginary can be modified to do something different with a little effort? This entire section of gifts are items one can program. The range from webcams to disco floor parts to cell phones.

Wireless Xbox 360 Controller for Windows

The newly released wireless controller can be used to play both Xbox 360 and Windows PC games, and best of all, you can program with it too. In fact, certain applications, like Virtual Earth 3D already include support for the Xbox 360 controller so you’ll be able to use your controller to literally fly around the world!

Cost: $37.99

Get it: Wireless Xbox 360 Controller on Amazon.com

Code it: The XNA Framework includes full support for Xbox 360 controllers for Windows and the Web using the XInput class. To learn the basics of programming your XNA controller, check out Paul Stubbs excellent Xbox 360 controller article as well as the newly updated version ported to work with the XNA Framework.

IrMan
Infrared man (Irman) is a small device that allows you to control your PC with the remote from your TV, VCR, CD or Stereo. You can use it to programmatically control any applications on your PC!
Cost: $40
Get it: IrMan Home Page
Code it: Duncan MacKenzie, the first Coding4Fun author, posted a classic article on using an IrMan through a Pocket PC using Visual Studio .NET 2003.

Nintendo Wii Remote

Why the Wii Remote without the Nintendo Wii? Because some clever hackers figure out how to get information out of it. The Wii Remote is actually a Bluetooth device that has an XYZ accelerometer in it. With some computing, one is able to figure out the tilt of the controller.

Cost: $53.67

Get it: Nintendo Wii Remote on Amazon.com
Code it: [Link coming soon]

Pedometer with PC Download

Geek out, even when your exercising using this built-in pedometer

Cost: $59.99

Get it: Pedometer with PC Download

Code it: With the included PC download software, users can easily export the data into a database and easily track their progress.

CrystalFontz LCD Displays
Using the new Serial Port classes in the .NET Framework 2.0, you can create some pretty cool applications to display dynamic information on a CrystalFontz LCD display.
Cost: $60-$80
Get it: CrystalFontz Home Page
Code it: Scott Hanselman has a great article that shows how to display what's playing in Windows Media Player on an LCD display and Kit George has a cool Space Invaders Console game demo that he hooked up to an LCD display to control how you fly the spacecraft.

Phidgets

Phidgets are a low cost, easy to use building block that connects to your PC through USB. Through a very robust API, developing applications is quick and easy. They have RFID, electrical relays, Servos, LED, multiple different types of sensors, and even a Pan & Tilt Web Cam kit.

Cost: $75 and up

Get it:

Code it: Scott Hanselman created a weather collection program and Brian Peek created a motion-detecting Halloween prank from one.

Airlink Network Camera AIC 250

Enjoy full motion video over a wireless connection with this easy-to-setup Web cam with built-in support for DSL or Cable model DHCP.

Cost: $99

Get it: Airlink Network Camera at Frys.com

Code it: Scott Hanselman’s got a great article that shows how to programmatically detect motion using the AIC 250 Network Camera.

GPS Receiver with Microsoft Streets & Trips 2007

Where am I? With Microsoft Streets and Trips, it provides a turn-by-turn speech support and .NET integration. This software and GPS combo can be used with your laptop, Tablet PC, Windows Mobile device to find your way when asking for directions won’t do.

Cost: $129.99

Get it: Streets and Trips 2006 on Amazon.com

Code it: Scott Hanselman again comes to the rescue with a great article on how read data off of the GPS receiver.

MAKE Controller Kit

Need a relay controller? How about a device that is Ethernet ready? USB too? Need digital Inputs also? Don’t worry, MAKE has you covered with their MAKE controller. It has all of the above functionality and more. More so, it has API for .Net, Java, Max & Pd, Flash, C / C++. You can even network multiple controllers together to create a more complex device.

Cost: $149

Get it: Make Controller Kit

Code it: The Make Controller Kit features a .NET library for easy programmability that can be used with any managed code language including VB, C#, and C++.

Z-Wave PC SDK Starter Kit

Intermatic’s HomeSettings Lighting Control Starter Kit is an easy way to help automate your home. Want your lights to turn on at 7 pm or control your home entertainment system’s lighting, the Z-Wave makes it rather easy.

Cost: $149 not including discount for registered Express users

Get it: Z-Wave PC SDK Starter Kit

Code it: The Z-Wave PC Starter Kit ships with the SDK, .NET Framework API and full documentation to get started. You can get help using the SDK on the ControlThink Forums.

Learning Edition Microcontroller Kit

Whether you’re young or old, learning the ins and outs of microcontrollers can be tricky. You can now learn the basics of microcontrollers including programming sensors, motors, resistors, microphones, diodes, capacitors and more.

Cost: $149.95

Get it: Microcontroller Kit Home Page (source: Wired Gift Guide)

Code it: The kit includes built-in programmability for controlling your hardware.

Disco Dance Floor Parts

If you want your home to be disco’ed out, you can get the PCB hardware boards from the people over at MIT who originally designed it. They also have boards pre-constructed if surface soldering isn’t your forte for an additional cost. Not sure on what types of LEDs to buy or how to do the cabling? They have that too now!

Cost: $35 to $450 dollars per board

Get it: Dropout Design

Code it: You can’t go wrong with Clint Rutkas’s Coding4Fun article for how to build out your own disco dance floor!

Sirius Conductor Satellite Radio Tuner

For Sirius Satellite radio fans, you can program macro-like behavior using the Z-Wave Sirius Radio Tuner. Because it’s Z-Wave, you’ll be able to easily program it or any other Z-Wave Products using the Intermatic .NET Framework 2.0 gear.

Cost: $149.99

Get it: Z-Wave Sirius Radio Tuner at Circuit City

Code it: If you have the Z-Wave PC SDK with Intermatic Home Settings Lighting Control Starter Kit, it includes the ControlThink SDK which enables you to easily program Z-Wave gear.

Windows Mobile Smartphones

The Samsung Blackjack, T-Mobile Dash, or the Motorola Q are great at making complex life easy. They run Windows Mobile 5.0 Smart Phone edition and are slim and small. With this Windows Mobile Version, you won’t be able to alter Office Documents, but you’ll be able to view them through Picsel Viewer. All these phones have a full QWERTY keyboard on them.

If you need more power, upgrade to a Cingular 8515, a Treo 700w, T-Mobile MDA, or the Samsung SCH-i730. These phones have larger screens that are touch sensitive and while physically bigger, they can do more. Unlike the phones above that run the Smart Phone edition these run the Pocket PC Edition. With these phones, you get Microsoft Office Mobile Suite so one can create and editing of Office documents.

Price: $199 - $600

Get it: Windows Mobile Smartphones

Code it: You can use Visual Studio 2005 Standard Edition, one is able to develop for these devices and create software with ease, like Bryan Dougherty’s Mobile Pac-man

StreetDeck Software

StreetDeck software is the ultimate must-have software for pimping out your car. StreetDeck includes, GPS Navigation, internet-enhanced navigation using Google Maps or Microsoft Live Local, Media Sync for your MP3 collection, games, and best of all, there’s an SDK so it’s fully customizable.

Cost: $199.99

Get it: StreetDeck software on MP3Car.com

Code it: Streetdeck includes a SDK for programming using VB Script, similar to Office VBA, and you can also build a .NET add-in in Visual Basic, C#, or C++ by making it available through COM.

eStarling Wi-Fi Email/RSS-Enabled LCD Frame
This frame enables users to either run an email configuration or RSS feed configuration so you can choose to write an application that dynamically sends an email (say from a Webcam periodically), dynamically upload your pictures to Flickr, or create your own RSS feed with pictures.

Cost: $249.99

Get it: eStarling page on ThinkGeek.com

Code it: You can use Sam Judson’s Flickr .NET API to easily programmatically send pictures to Flickr, or use the FlickrWebCam application to have mom get real-time pictures of you from your Webcam or use the SmtpMail Class to email a picture attachment in one line of code.

Home Theater and Lighting Controller 300 featuring OmniLinkTM
If you have your house setup for Z-Wave Home Automation, then you’ll want this programmable remote that enables you to easily control your lights, home theater and more.

Cost: $599

Get it: Home Theater and Lighting Controller 300

Code it: If you have the Z-Wave PC SDK with Intermatic Home Settings Lighting Control Starter Kit, it includes the ControlThink SDK which enables you to easily program Z-Wave gear.

Windows Media Center

Now is a great time to upgrade your old PC, like the Dell XPS 410 a PC Magazine Editor’s Choice that ships with Windows Media Center 2005, but includes a free upgrade to Windows Vista Home Premium which includes a revamped Media Center with built-in streaming to your Xbox 360.

Cost: $999 - $2,500

Get it: Dell Online Store

Code it: Windows Vista Media Center has a much-improved API and three different ways to mod Media Center including HTML, XAML, and Media Center’s own markup language using the Windows SDK.

Robotics

Mr. Roboto, please come to the front, your Roomba is waiting for you. This entire section lists robots and electronics that do everything from a vacuum cleaner to creating your own cellphones to GPS.

Microbric Viper Robot

The Microbric Viper robot enables you to build complex electronic devices with little or no prior electronics knowledge and no soldering required.

Cost: $89.99

Get it: Microbric Viper Robot and Serial IR Transmitter/Receiver

Code it: Scott Hanselman walks through programming a Microbric Viper Robot

Lassen iQ FAT16 Datalogger - Complete Kit

Ever think you constantly walk in circles? Think you could optimize your routes if you only could map where your went? Use this GPS device to passively map your routes, all you need is an SD card added in. Then return to your computer, upload your data and see where you wandered. Great for mapping routes biking or hiking.

Cost: $150.70

Get It: Spark Fun

Code It: From their GPS Logger Datasheet, you can get it to work with Google Maps or create your own from the specification provided.

Parallax Bluetooth Boe-Bot Kit for Microsoft Robotics Studio

Using Microsoft Robotics Studio, you can easily program the Boe-Bot Parallax kit over Bluetooth and best of all, the Robotics Studio team has negotiated a 15% discount on the BoeBot.

Cost: $198.77 after 15% discount

Get it: Parallax Boe-Bot Kit

Code it: You can use Microsoft Robotics Studio which exposes services to control your Parallax Boe-Bot Kit using Bluetooth.

iRobot Roomba

It’s not just a vacuum cleaner it’s also your programmable minion! You can use the clean-the-house excuse as your justification for getting this friendly house cleaner.

Cost: $229 or $339 depending on model

Get it: Roomba Red + RooTooth bundle, Roomba Discovery + RooTooth Bundle

Code it: You can use Microsoft Robotics Studio which includes built-in services for Roomba programming.

LEGO Mindstorms NXT

Lego Mindstorms NXT is Lego’s newest release of their popular Mindstorms robotics and includes built-in three motor support and multiple sensor support including motion, touch, sound, and light.

Cost: $249.99

Get it: Lego Mindstorms on Amazon.com

Code it: You can use Microsoft Robotics Studio which includes built-in services for Lego Mindstorms NXT programming.

GM862-GPS Evaluation Cell phone Kit – USB

Looking to write your own cell phone software? Just pop in your SIM card and get to it. Spark Fun has an evaluation cell phone board with GPS that can interface with your computer through USB.

Cost: $274.65

Get It: Spark Fun

Code It: You can find the documentation for how to start interfacing with the board and Spark Fun provides a Visual Basic example.

White Box Robotics PC-BOTs

Whitebox Robotics has created the closest thing to having R2D2 at home with their newly released PC-BOTs. While it’s the priciest of all robotics kits, it’s hardware is no joke as it includes 1GB of RAM, an 80GB hard drive, Windows XP Home, DVD Drive, and a wireless network card.

Cost: $3,995 for the Developer kit, $4,995 to include the ever-so cool panels.

Get it: 914 PC-BOT, 9-Series PC-BOT both from PCPowerzone

Code it: You can use Microsoft Robotics Studio to program Whitebox Robotics devices (video).

Tira – Infrared Remote Control Receiver/Transmitter

Eric Gunnerson pointed us to Tira, or Transmitting InfraRed Adapter, which is a device that enables you to send and receive infrared signals to any IR device, say to control home automation, or to change your TV channel. Best of all, it’s fully programmable so you can control when to send IR signals or what happens when it receives IR signals.

Cost: $49.00

Get it: Tira 2.1 on Home Electronics

Code it: Tira’s Developer Page includes a downloadable SDK which includes a DLL that you can call from any .NET language or directly from C++, once you install the Tira drivers.

Programmable Games

Think the final boss is too hard? "Modify" the game to give yourself that extra edge. As any Coding4Fun reader can tell you, games are more fun when you can mod them, and we’ve chosen our favorite moddable games that you can take and extend to your heart’s content.

Rocket Commander

Benjamin Nitschke’s Rocket Commander is both fun and educational as Ben put together 10 step-by-step videos that show how to build a fully moddable an immersive 3D game using Managed DirectX and C#.

Cost: Free

Get it: Rocket Commander Game

Code it: Watch all 10 videos and download the source code to start building your own RocketCommander mod.

Mech Commander 2

If you're interested in how real commercial games are built, look no further than Mech Commander 2, a real-time strategy game with full source code available released by Microsoft Game Studios. If you're a C++ developer you can learn how to build your own mods to Mech Commander in these three free webcasts

Cost: Free

Get it: Download the full source code (1GB)

Code it: Mike Klucher from the XNA team gave a 3-part on-demand Webcast series on how to mod Mech Commander 2that you should use as your starting point: Part 1, Part 2, and Part 3.

World of Warcraft

If you haven’t started playing World of Warcraft, you simply don’t know what you’re missing! With the Burning Crusade Expansion Pack coming out on January 16^th, now is a great time to join this ever-evolving world!

Cost: $19.99

Get it: World of Warcraft on Amazon.com or pre-order the Burning Crusade

Code it: World of Warcraft scripting and add-ins are coded in LUA, which you can add Visual Studio 2005 support (Standard and above), or check out David Nikdel’s WoW-360 Project, or UniUploader (screenshot) which enables you to dynamically upload much more detailed players stats to a WowRoster portal.

Neverwinter Nights 2 Limited Edition DVD

Neverwinter Nights 2 is a popular Dungeon and Dragons game that enables users to create their own worlds and adventures and includes a large community of users building games and dungeons for you to explore

Cost: ~$34.99

Get it: Neverwinter Nights 2 on Amazon.com

Code it: The Neverwinter Nights game builder is written in C# using the .NET Framework and you can write Game Builder plug-ins using any Visual Studio 2005 language including VB, C#, or C++.

Civilization IV

Sid Meier's Civilization IV is an unlike the typical Age of Empires battle strategy game in that players can use everything from diplomacy to technology to advance their civilization.

Cost: $39.99 or $19.99 for the expansion

Get it: Civilization IV on Amazon.com or Warlords Expansion Pack

Code it: Civilization IV includes a Python and C++ SDK and, while we haven’t tried it, you may also be able to call the DLL from VB and C#.

Half Life 2 Holiday 2006 Collection

The Half Life 2 Holiday 2006 Collection includes Counter-Strike: Source, Half-Life 2, Half-Life 2: Deathmatch, Half-Life 2: Episode One, Half-Life Deathmatch: Source, Half-Life: Source. The good news is that you can now officially use Visual C++ 2005 Express Edition for your Half Life 2 mods.

Cost: $49.95

Get it: Holiday 2006 Collection

Code it: Valve’s online wiki SDK docs include everything you need to get started including steps to get Visual Studio 2005 working.

Flight Simulator X Deluxe DVD

While Flight Simulator X’s hardware requirements are quite big, the graphics on Windows Vista using DirectX 10 are nothing short of breathtaking.

Cost: $49.99

Get it: Flight Simulator X on Amazon.com

Code it: The Deluxe edition of Flight Simulator X includes a new SDK called SimConnect that you can use to manipulate and control the Flight Simulator world using VB, C#, or C++.

Software Tools

Tools to help make video games, robots and webpages oh my! Every good craftsmen needs their tools and we’re no exception. Below is a list of tools and tool add-on's that will make anyone's life that much easier.

Microsoft Robotic Studio

If you have LEGO Mindstorm RCX or NXT, you actually can control them through Microsoft Robotic Studio. It can control far more than just LEGO too, it is able to control far more and comes full of examples. Instead of having to deal with low level coding to deal with everything on your robots, one can write a wrapper then have the Robotic Studio do all the heavy lifting!

Cost: Free

Get it: Microsoft Robotics Studio

Microsoft Visual Studio Express Editions

You can get everything someone needs to code in 6 different flavors. Web Development, SQL Server, Visual Basic, C#, C++, and J# Editions are available for download from Microsoft. They are the perfect gift for the hobbyist, novice or student developer that is looking for lightweight, easy to learn and use tools. Each edition is able to run side by side on your computer with other installations so you can collect them all!

Cost: Free

Get it: Visual Studio Express Editions

Microsoft XNA Game Studio Express

Think you are cut out to build video games? Using Microsoft Game Studio Express you can try out building video games that can be played. If you have an Xbox 360, you can actually transfer the game you created to it too! You can show off to your friends the games you created (Don’t forget to add in a god mode for yourself).

Cost: Free for Windows/$99 year for Xbox porting and content subscription

Get it: XNA Game Studio Express

Paint.NET

Paint.NET is a free image and photo manipulation software that is open source too! Paint.NET is written in .NET 2.0 and mostly is c# and has a small amount of C++. It supports layers, unlimited history, a simple and intuitive interface, and is loaded with special effects. While it isn’t an Adobe Photoshop replacement, it is simple and powerful enough for someone on a budget.

Cost: Free

Get it: GetPaint.NET

Code it: Paint.NET has a managed API that you can write plug-ins for using any managed language as shown in this Code Project tutorial by Dennis Dietrich.

Reflector for .NET

Do you have a program that is written in .NET and you can’t figure out how it they preformed a certain task? You thought you fixed that bug but it is still happening after you deployed it. Use Reflector it to see how they pulled it off and verify deployments! Reflector is capable of showing the source code of DLL’s in .NET 1.1 and 2.0 in both Visual Basic and Visual C#. What is displayed isn’t a 1 to 1 code representation, instead what the ILM runs, however one can figure out how certain tasks are accomplished and should be able to gauge what is happening.

Cost: Free

Get it: Reflector for .NET

TeamSpeak

If you’re a gamer, you’ve likely used TeamSpeak or Ventrilo to have live chat while playing online games. For us, the choice between TS and Vent came down to who has the API’s, and it was clear that TeamSpeak is the way to go given its built for extensibility

Cost: Free

Get it: TeamSpeak

Code it: You can find a couple of .NET TS samples including Peter Barette’s C# Chat Text application or Oliver Flint’s TSDisplay.NET (live demo) using ASP.NET

UltraMon

If your coder has multiple monitors, you may think about getting them UltraMon. UltraMon extends out the Windows Taskbar across all the monitors along with the ability to create shortcut keystrokes to send windows to different monitors. In addition, it allows for each monitor to have a different display profile. Plus it has scripting support!

Cost: $39.95

Get it: UltraMon

Code It: Ultramon has a SDK along with scripting support.

Microsoft Visual Studio 2005

If developing for mobile applications or want to use 3^rd party Visual Studio add-ins, you’ll need to upgrade to Visual Studio Standard or Professional Edition. Visual Studio Express Editions projects will seamlessly work with the full versions of Visual Studio.

Cost: $179 - $679

Get it: Standard Edition (upgrade price), Professional Edition (upgrade price)

Code it: Visual Studio 2005 includes a free SDK that you can use to create your own add-ins or even your own programming language.

JetBrains ReSharper

ReSharper is an add-in to Visual Studio 2003 and 2005. ReSharper provides an intelligent coding assistance, on-the-fly error highlighting (no more recompiling), additional searching and navigation features, unit testing, and realy time analysis of code warnings / errors … the list goes on and on. JetBrains ReSharper is free to try out for 30 days, $200 for a full copy.

Cost: $200

Get it: JetBrains ReSharper

Code it: ReSharper has an open API which you can use to modify how your code is refactored.

WebSuperGoo ABCpdf

PDFs are everywhere and progressively more applications are needing them. AbcPDF allows a developer to easily manipulate or create dynamic PDFs. It is fully multithreaded and is loaded with stock full of examples to figure out everything. Past just normal PDF generation, it also can do HTML to PDF generation.

Cost: $328, Possibly free if you link to them.

Get it: WebSuperGoo

Code it: Here is their API for ABCpdf.

Top 10 Cool Presents for Developers

What are your top 5 favorite ... wait, this isn't a movie. Here are what Coding4Fun would deem Top 10 cool presents for Coders. Some range from a magazine subscription to DNA. Each one is

Optimus mini three keyboard

Wondering how much CPU or RAM your system is taking up? How about what the weather is? The Optimus mini three keyboard allows you to view what is going on in the world with animation.

Cost: $159.99

Get It: Optimus mini three keyboard on ThinkGeek

Code It: The Optimus Mini has a c# library to use along with other languages which can be found here.

O'Reilly Safari Books Online Subscription

Wonder why FireFox and Internet Explorer's JavaScript Dom acts different for the same property? Me too. That is why I have a ton of O'Reilly books at my desk. With their online solution, one has the entire library to their disposal. No need to go through pages upon pages of search results!

Cost: $39.99 per month

Get It: Safari Books Online

MAKE Magazine

MAKE magazine is a magazine that actually encourages you to break your warranties. Wonder how to do modify your camera to do strobe photography, they’ll explain how to create a rig to create. How about a toy gun alarm clock? A jet made out of a jar? A 5-in-1 network cable? These are just a few of many things they show people how to make in their quarterly magazine. In addition to their magazine, they have a great blog over at http://makezine.com/blog/.

Cost: Register your copy of Visual Studio Express and get 5 issues for the price of 4.

Get it: Make Magazine

Color Call

You’re in the middle of a meeting and you’re up on the whiteboard. The phone rings, should you answer? Find out easily with the Color-Call Caller ID System which enables you to setup which phone numbers should correspond to up to four different colors.

Cost: $29.99

Get it: Color-Call Caller ID from Brookstone

Scrolling LED Belt Buckle

Nothing says geek chic like a scrolling LED Belt Buckle. It can hold up to six messages at a time with each message containing 256 characters. You can see pictures of our very own Sara Ford wearing the Scrolling LED Belt Buckle.

Cost: $29.99

Get it: Scrolling Belt Buckle

Self Destruction Button USB Hub
You can’t go wrong accessorizing your office with this custom USB Hub that would be perfect for Dr. Evil. Just remember, do not press the red button no matter how much you want to.

Cost: $64.66

Get it: Self Destruction USB Hub from GeekStuff4u.com

Alesis USB Podcasting Kit

For your inspiring Podcaster, the Alesis kit takes the guesswork out of podcasting. It comes with an 8-Channel USB Mixer, dynamic microphone, stand, and headphones. It also comes with 30 days of free hosting for your podcasts.

Cost: $250

Get it: Alesis USB Podcasting Kit

Matrox DualHead2Go / TripleHead2Go

Afraid which new video card is right for you or are you on a laptop? The Matrox allows a coder to have up to three monitors with the TripleHead2Go (two with the DualHead2Go) with only one video input. Multiple monitor support is build into Windows. While having that many monitors may seem a tad excessive, they do help boost productivity and help the keep workspace less messy.

Cost: $169-$299

Get it: Matrox Products

DNA Portrait

The ultimate in personalized artwork, this portrait is created by using your actual DNA and comes in fun color choices like Firesky, Ice, Citylights, and Citron

Cost: $390 for 18” x 24”, $490 for 24” x 36” and $790 for 36” x 54”

Get it: DNA11

22”+ wide screen monitors

What is better than having dual monitors? Dual 22” widescreen monitors. Bigger monitors aid in the ability to read more and have been shown to have boost productivity 10 to 44%. Please verify the graphic card / device they have can support a monitor of this size.

Cost: $400-$500

Get it: Dell or NewEgg lists of 22”-23”+ or 23”+

C++ Programming Books

Every programmer needs C++ books. Some need a C++ GUI Programming Guide while others need a primer book. The gift of reference books is always a good bet.

Cost: $30 to $50

Get it: Amazon

Happy Holidays From Coding4Fun!

Now only if I can get someone to get me all these gadgets, software, and toys, I mean highly educational, non-fun devices. Thanks for reading and if you think we've missed any awesome holiday gift, please Email us and we’ll get it added to our list. If you like the guide, Digg Us.

Kid's Programming Language: Santa's Gifts

Coding4Fun — Fri, 01 Dec 2006 12:42:00 GMT

	This article is in a series in which we are recreating classic video games in KPL code—in this article, Santa's Gifts
Larry Serflaten Difficulty: Easy Time Required: 1-3 hours Cost: Free Software: Kid's Programming Language Hardware: Download: Download

One way to get started programming games is to pick a popular game that is fun to play, that has all of the rules already made up, and develop a program that just transfers that game to the computer. Doing that much will help beginning programmers raise their programming skills as they code and tweak their own rendition of the fun game. A Christmastime example of that method accompanies this article, programmed using a relatively new programming language designed to help beginners gain programming skills. Kids' Programming Language (KPL) is a simplified but modern programming language and development environment that introduces beginners to the basic programming concepts. Just as many famous sports players start out playing sports while they're young, KPL is a tool kids can use to program computers while they are still young. With KPL being a free download, it is well within their budget!

The referenced KPL game is called Santa's Gifts, but it is very similar in nature to the popular Tetris genre of falling objects that need to be properly positioned for optimum points. The rules and game play is simple to learn, but strategically placing the falling objects will give the advanced players higher scores. Using the arrow keys to move the objects from side to side allows the player to position them where they want. Pressing the Down arrow key lets the object drop. When three or more objects of the same type are positioned together, they form a group that is removed from the drop zone, adding some number of points to the player's score. The strategic part of the game is to try to build groups of four or five items, or to try to cause chain reactions where the removal of one group causes another group to be formed and removed. Both of those methods yield more points than just creating groups of three. There is a time aspect to the play as well. The player can't take all day to decide where to position the next item. The time to decide is decreased as the levels progress, which will cause the player to have to recognize certain patterns that score better, decide on a strategy to complete those patterns, and go for it in a relatively short period of time.

Do some functional testing

If at all possible, create the game on a piece of paper first, or use pieces of paper to represent objects in the game, and set it all out on a table top to run through the game a few times. Get input and feedback from other game players, and check it over to see if the rules are easy to learn, and if there is opportunity for advanced players to gain an advantage at beating the game. You'll want to iron out the problems and any other conflicts on paper as much as possible before they become problems while writing the game code. It is much easier to change a rule on paper than retrofit a new rule into the computer program. For the simpler games, some may do all of that planning and checking in their head, as I know I did on more than a few occasions, but it cannot be stressed enough to do the planning first, to avoid scrapping or re-writing whole sections of code.

As I mentioned before about the sports heroes playing the sport while they were young, it takes many years to develop the skills needed to play professionally. They certainly didn't do everything right while they were learning. Expect a little of that in yourself. Those professional players didn't quit, and they kept going until they made it to the top. That sort of perseverance is what you'll need to get past the few failures that may happen. If you can't get the programming to work one way, try another route. Don't be discouraged about starting a project over, or trying to do it in a new way, especially as you begin to develop your skills. Mentors, or others familiar with the tools you are using, are a good source of information and can help you find the right path, instead of the trial and error mode of learning.

In summary:

Begin a new game by writing the storyline. Describe where the player is coming from, and where he has to get to. Include the objects or obstacles he will meet along the way, and then move on to creating the rules of engagement. Pretend your table top is your computer screen and cut out pieces of paper to represent the objects the player will see on the screen. Play the game several times, taking notes of any conflicts or other ideas that will be included in the game. Refine the movements and game play such that a child can learn it fairly quickly and figure out how to add something the advanced players can use to gain an upper hand. Begin coding the program by adding just a shell that shows how the screen will look, and provide the means to start the game, and whatever needs to happen to end the game. Then start adding routines to get the game up and running. For example, if there is going to be five levels to the game where each level shows a different screen, then start with a loop in your main procedure that iterates 1 to 5, that will call the routines to draw the different screens as they are needed. Just get the basic shell in place as the starting point. Then add the objects that make up the game, such as adding the player to the screen, and allowing him to move in each of the levels. Then add the objects to the different screens, or whatever the player will be interacting with, and so on. Piece by piece, build the game by providing the skeleton and then adding the meat. You can do that on the whole game level, and on a finer level for different routines. Be mindful of saving your work at different milestones, and then working with a copy from there. You should save your work periodically, at various milestones, so that if the day happens where your file gets corrupted, or you code yourself into a corner, you can go back and make another copy of the last milestone and get back into it, instead of having to start all over from scratch.

About the game listing...

For those who are going to be looking at Santa's Gifts source code, I want to point out a couple techniques that might be useful in your own games. The first is in translating a one-dimensional array into something that represents the two-dimensional screen; specifically, checking for objects that are in the immediate area of the player. The second is the method I used to create the fading points that are shown when groups are removed from the play area. For people who do not yet have a copy of KPL, you can learn more about it from www.kidsprogramminglanguage.com.

KPL only supports arrays of a single dimension, so representing two-dimensional space takes a bit of doing. In particular, X and Y coordinates have to be translated into an Index value that points to an element in the array. In general terms, transposing between the two can be shown by the following code:

// XMax is the maximum extent of the 2D space in the horizontal direction 
X = Index Mod XMax
Y =  Index / XMax
Index = X + (Y * XMax)

That works when the arrays begin with the first element at index 0. Currently KPL begins its arrays at an index of 1, (but that may change!), so the above code becomes:

X = (Index - 1) Mod XMax
Y = (Index - 1) / XMax

Because the KPL single dimension array uses the Index value to reference its elements, it is more often easier to work with the 2D grid cells by manipulating the Index value, instead of the X and Y values. When the game code has to check for any objects in a grid cell adjacent to the player, it can test the next cell to the right by adding 1 to the player's Index value, and the cell to the left by subtracting 1 from the player's Index value. Similarly, to check the next cell above or below the player, XMax can be subtracted or added (respectively) to the player's Index value. Of course boundary checks are needed to avoid looking above the top edge or below the bottom edge, which are easily handled by testing the adjusted Index value to be between zero and the upper bound of the KPL array. But boundary checks on the right or left edge are more difficult to handle when using the Index value.

To represent a checkerboard, for example, the KPL array would hold elements indexed from 1 to 64 which represent the 8 X 8 grid. A value at Index 1 is the same value for the grid coordinate (0, 0) or (1, 1) depending on which value you prefer to begin numbering with. Assuming the upper left cell is at (1, 1) then the next cell to the right of the upper left cell is at (2, 1) with an index of 2, (3, 1) is Index 3, (4, 1) is Index 4, and so on to the upper right cell which is at (8, 1) corresponding to the KPL array Index value of 8. The cell below the upper left corner cell is at (1, 2) which equates to an index value of 9. And so it goes with the Index value incrementing by one as the grid cells are traversed left to right and top to bottom.

The trouble arises when the player is at the right or left edge, because adding one when the player is at the right edge, or subtracting one when the player is at the left edge will actually be referencing a cell from a different row. If the player is at cell (8, 1) or Index 8, then the code must not add 1 for the adjacent test because the player is at the edge; there is no cell at (9, 1).

One way to avoid overstepping the boundary is to convert the Index value back into its X and Y coordinates so you can test X in comparison with XMax. But there may be many places where such a check is made, which would require many such conversions. Even if centrally located in a function somewhere, the code must be called, which takes some amount of time, repeatedly, over and over, every time such a test is needed.

The method I used instead of repeated boundary conversions effectively adds a blank cell to the right edge of the 2D space. The KPL array was lengthened to account for there being a cell there, but it was never used for player movements. What it did was avoid the need for special case tests for the right or left edges. Upper and lower boundaries were still in place, but adding that extra cell meant I could simplify the code used to test the adjacent cells. I could safely increment the Index and check for objects for tests to the right, and I could safely decrement the Index value and check for objects to the left because there was that extra cell at the end of each row. Tests to the left when the player was at the left edge found a blank cell (obviously no object there), and tests to the right when the player was at the right edge also found a blank cell. With a little tradeoff in memory usage, I simplified my code considerably. Check out the CheckAdjacent routine in the game source code. It turned out to be nice uniform code that tests for upper or lower boundaries ahead of comparing the objects for similarity. That is the code used to find all the members of the same type for inclusion into a grouping. If a similar gift is found in an adjacent cell, then adjacent cells to that one have to checked for further similar gifts. If checking there finds one in an adjacent cell, then that new one has to have its adjacent cells checked as so on, to find all the gifts of the same type that are next to each other. You'll note the repetitive nature of those tests made for a good place to use a recursive call (where some routine calls itself to complete its task), but recursion is entirely another topic, worthy of its own detailed discussion.

The second technique I wanted to mention allowed me to print text on the screen and have it fade away. It was just one of those what-if discoveries I made while looking for a simple way to show the points for the currently removed group, without it remaining on the screen too long. I had used the Status area, but I didn't like how the points shown there seemed to be more like debugging information and not really a part of the game. What I did was take part of the screen image and make it partially transparent using my favorite paint program. I placed that translucent image in a sprite and used KPL's StampSprite method to transfer the image to the screen. I found that I could print text to that area, and periodically stamp that translucent sprite over the text which would gradually erase the text. I also used that method to provide the BRIGHTNESS constant you'll find near the top of the listing. It controls the brightness of the background image. I didn't want the background image to be so bright as to distract from the animated gift images. I wanted a kind of lower-contrast image to avoid that distraction. When I found the translucent sprite could be stamped in place several times to build up to being opaque, I decided that would be how I could lower the contrast of the background, by making the background sprite translucent. It has to be translucent over some color or shade, and that is what the BRIGHTNESS value controls: it decides the brightness of the gray color used behind the translucent background image.

One final note on playability. On faster computers you may find that the program runs way too fast to play. That is the way I have grown accustomed to designing programs. Design them so they can play faster than the human can because the computer can easily be slowed down to let the human catch up, but it is usually more difficult (or nearly impossible) to try to speed up a program when it runs too slow. Also near the top of the listing is a TIMEDELAY constant you can adjust to slow down the game more to your liking and abilities.

I hope you enjoy playing Santa's Gifts, and that you'll take up writing and sharing programs of your own design! If you need beta testers for your KPL program, or have questions or comments, do visit the KPL forums available from links in the help menu of the KPL environment.

Kid’s Programming Language: Christmas Tree Shooter

Coding4Fun — Thu, 23 Nov 2006 08:39:00 GMT

	This article lights on a language called Kids Programming Language (KPL). This is a very easy language and especially made for people which are not the memeber of programers team. It mainly deals with games.
Walt Morrison and Jon Schwartz Difficulty: Intermediate Time Required: 1-3 hours Cost: Free Software: Phrogram Hardware: Download: Download

Ho Ho Ho! Merry Christmas! Happy Holidays! Ho Ho Ho! Naughty or nice? We don't really want to know! Ho Ho Ho!

Have you seen the previous articles here at Coding4Fun about KPL, the Kid's Programming Language? The overview and the article on KPL Pong. KPL is not just for kids; it's for anyone who wants to code fun stuff fast. Proving the point, we're working on a couple of Holiday-themed KPL games and articles—like this one, ChristmasTreeShooter.kpl! We have a fun and easy suggestion for how you and family or friends can modify the game yourself, too.

For some unknown reason, your Christmas tree is bobbing and weaving unpredictably before your eyes. It just won't hold still! And you have the rest of these ornaments that you have to hang on the tree, or you can forget about opening that green box. You suspect it's got an Xbox 360 in it, and going with that theory, you're not shaking it like the others. Just in case. Anyway, you do your best with the ornaments, and Santa rates your performance at the end. Not a guy you want to disappoint, coming down to that Christmas Eve wire...

This KPL game was implemented in 161 KPL instructions, and will be simple code for an experienced or hobbyist programmer to follow. It uses sprites for graphics and uses custom sound clips, which we're going to show you how to replace with your own voice-overs. What are friends or family going to say when it's you who rates their performance? Are you going to be deadpan and droll? Acerbic and insulting? Will you do a Santa voice, a Mrs. Claus voice or an Elf voice? However you record it, you know it'll be fun!

Chances are, if you're here at Coding4Fun, you're more than just a beginning programmer—but I bet you can think of some friends or family who might like to be a beginning programmer? Well, we made KPL for them—and you helping them learn with KPL should make it fun and easy for both of you. This game ought to catch their interest, but if they're a novice perhaps you can help them through the Beginning Programming with KPL Tutorial before you work with them on this or other KPL game code.

Just the interesting stuff, please

This article will assume some basic programming skill, and rather than explaining every line of code in the KPL program, will focus on key techniques or algorithms which will be useful as you develop your own KPL games:

Finding free images online
Using Sprites in KPL
Recording and using custom sounds
Using Arrays
Handling keyboard input
Sprite interaction
Allowing user customization of game behavior

Before we begin, the article will make the most sense if you have installed KPL, and downloaded and unzipped the Christmas Tree Shooter program underneath your KPL install folder. The ideal way to start, of course, is to load ChristmasTreeShooter.kpl in the KPL IDE, click "Run the program," and play it a few times before examining the code. :)

KPL and this program are both available as freeware downloads from: http://www.kidsprogramminglanguage.com/download.htm. KPL does have a dependency on the .NET Framework 1.1, and the KPL install will "auto-magically" download and install the Framework if it is not already installed on your machine.

Finding Free Images Online

There are many many places online that offer free images that you can reuse in your own KPL programs. An MSN Search for "Christmas Tree Clipart" returned 589,677 search results when I ran it. Here's the page where we found our Xmas tree:

http://www.geocities.com/~bug_hut/Christmas/trees.html

That particular page is of interest because it's been viewed over 200,000 times—who'd have thought?!? And because it is the only web page I can think of using a background WAV file that I actually liked hearing!

KPL supports images in all standard file formats, including GIF, JPG, PNG, TIF and BMP. KPL does support animated GIFs, but those are not used in our Christmas Tree Shooter. If you're using Internet Explorer, saving an image you find on the Web for reuse is easy: right-click the image, and select "Save Picture As...". KPL will automatically find an image by file name if the image is in the Media\Images folder under the KPL installation folder; if you expect to use an image from more than one KPL program, this is the right place to put it. If an image is specific to the program you are working on, you can leave the image in the same folder as the .kpl program itself. KPL will find it in the local folder, looking there first before checking the Images folder.

Of course, the caveat about finding images online is making sure the site allows you to reuse the image. Image reuse happens all the time on the Web, but of course, if you find an image with a copyright or other usage limitation stated on the page, you will want to comply. There are many many freely usable images out there, so it's safest and simplest to keep looking until you find one with no strings attached.

Using Sprites in KPL

Here's a single method we coded that wraps the basic KPL sprite commands into one:

Method LoadSizePlaceSprite(name As String, file As String, 
                           scale As Decimal, x As Int, y As Int)
    LoadSprite( name, file ) 
    ScaleSprite( name, scale )
    MoveSpriteToPoint( name, x, y )
    ShowSprite( name )    

End Method

This allows a single call to load, place and display a sprite:

LoadSizePlaceSprite("TREE", "Christmas Tree3.png", 1.50, 
                     TreeX, TreeY )

The name parameter gives the sprite a name which you will use to refer to it when you manipulate the sprite.

The file parameter is the filename to the image file which will be used to represent the sprite on-screen. No path is required to the filename, but the file must be in the local folder with the .kpl program, or in KPL's Media\Images folder.

The scale parameter is a size multiplier for displaying the sprite. 1.0 is no size change, 0.5 is half size, etcâ€¦

The x and y parameters specify the screen location where the sprite will be displayed, in pixels, with the default being that the upper left corner of the window is location (0, 0).

KPL defaults all sprites to the same ZIndex of 0—all sprites are drawn or rendered on the same layer, so the last one drawn always appears "on top." SetSpriteZIndex(name, ZIndex) can be used to specify the ZIndex to control this. Sprites with a higher ZIndex will always be drawn on top of sprites with a lower ZIndex.

SetSpriteZIndex("Ball" + BallCount, 10)

Other Sprite-manipulating methods used in ChristmasTreeShooter.kpl are:

HideSprite() takes the name of the sprite which is to be hidden when it is no longer needed:

HideSprite("CrossH")

GetSpriteHeight() and GetSpriteWidth() return a height or width in pixels of the sprite:

GetSpriteHeight( "CrossH" )

SpritesIntersect() takes the name of two sprites, and returns true only if they intersect or overlap on the screen:

If SpritesIntersect("TREE", "Ball" + OrnamentCount) Then

That's all the Sprite code used in ChristmasTreeShooter.kpl. We have designed KPL to be as simple and as highly leveraged as possible, and this is particularly visible in KPL support for Sprites.

Recording and using custom sounds

This KPL program uses custom sounds for Santa's rating of your performance at the end of the game. As with images, sound files can be placed in the same folder as the program if they are used only for the program. If you'd like to share the sounds across more than one program, they can be placed into the Media\Sounds folder underneath KPL's install folder.

The sounds used for the game were recorded using the Sound Recorder, which is available as part of all versions of Windows. You can launch it from Start Menu > All Programs > Accessories > Entertainment > Sound Recorder, or by running sndrec32.exe from the Start > Run... dialog. If you've been a geek long enough, that file name will remind you of the good (?!?) old days. Not only of 32-bit Windows, but of 8-character MSDOS file names. Amazing thing is, that really wasn't very long ago. :)

The File menu and the tape-deck style button bar are all of the Sound Recorder that you'll need to use. KPL currently supports .WAV file formats. We're adding support for more sound formats—as well as the ability to play multiple, layered sounds—to KPL v 2, which is targeted for a January 2006 release. Any other program which allows recording or editing supported sound files can be used instead of the Sound Recorder, or course.

So, here's a fun, easy customization: use Sound Recorder to record and save your own version of the following sound files in place of ours! Here are our sounds and their scripts:

HoHoILikeIt.wav: "Ho Ho Ho! I like it!"

HoHoTryAgain.wav: "Ho Ho Ho! Try again!"

You can, of course, say anything you like, and/or give your recordings a different name. If you do use a different name, you'll need to change the following lines of KPL code to match:

If HitCount = 5 Then
    PlaySound( "HoHoILikeIt.wav" )
Else
    PlaySound( "HoHoTryAgain.wav" )

End If

Using Arrays in KPL

KPL does support the use of arrays, as well as user-defined structures. KPL v 2 will add support for user-defined classes—an ideal way to encapsulate logic such as the handling of our Christmas tree ornaments. Until then, we kept this simple by using arrays to handle the five of them:

Define BallX As Int[5]
Define BallY As Int[5]

Define BallOffset As Int[5]

And here is an example from the program showing the use of these arrays:

    BallOffset[OrnamentCount] = BallX[OrnamentCount] - TreeX

Handling keyboard input

A simple model for coding a game in KPL is a large loop which, at a controlled interval, processes user input and game events. Here is our Method Main(), which shows how this loop is the basis of the processing for the program:

Method Main()
    SetupGame()
        
    // Show Instructions    
    Alert("Use the Arrow keys to move the shooter and tap the 
           Space Bar to place an ornament. Placing an ornament 
           on another will break both!", "How to play!") 

    Define CurrentTime As Decimal 
    Define TimeLastChecked As Decimal
    
    // Start the wait time for the Space Bar to prevent the Key 
    // Bounce effect     
    LastOrnamentFireTime = TickCount()

    While GameOver = False
    
        CurrentTime = TickCount()    
        
        // If 60 milliseconds have not passes since the last 
        // time we checked, we don't do anything yet.
        If CurrentTime - TimeLastChecked > 60 Then 
            // Every 60 milliseconds (that's 17 times a 
            // second!) we fall into this block.
            // First we process Key events to move the
            // targeting circle        
            ProcessKeyEvents()
            // Then we MoveTheTree.
            MoveTheTree()
            // We reset the timer each time, so we wait 
            // another 60 milliseconds before moving again.
            TimeLastChecked = CurrentTime
        End If
        
    End While
    
    GameOverShowTree()
  
End Method

The actual processing of key events is done in the ProcessKeyEvents() method, using the IsKeyDown() function:

    If IsKeyDown( "Up" ) Then
        If CrossHY > 10 Then
            CrossHY = CrossHY - CrossHairSpeed
        End If

End If

The key processing code checks for all keys that are relevant to targeting movement, and will handle any and all keys that are down. It also uses logic as shown above so that keys which would cause the targeting circle to move off the viewable screen are ignored.

One issue caused by processing keys in a loop this way results from the fact that the computer loop can be so much faster than our own fingers on the keyboard, which can result in processing the KeyDown more than once on a single tap of the Space Bar. When the single Space Bar keystroke is as important to the game as it is here, we must add a little extra code which makes sure we don't process that Space Bar keystroke more than once. The following code, at the bottom of the ProcessKeyEvents() method, does this using the global variable LastOrnamentFireTime:

// Process the wait time for the Space Key to reduce the Key 
// Bounce Effect.  If it's been less than 200 milliseconds...
currentTime = TickCount()
If (currentTime - LastOrnamentFireTime) < PlayerOrnamentFireDelay Then
    Return // Exit the method without processing
End If
If IsKeyDown( "Space" ) Then
    LastOrnamentFireTime = currentTime
    ShootOrnament()

End If

Sprite interaction

What you are attempting to do with this game, of course, if place each of the five ornaments onto the bobbing and weaving Christmas tree, without breaking them. Since the tree and the ornaments are all implemented as sprites in this KPL program, this is as easy as checking to see whether the sprites "intersect" when you hit the spacebar to place an ornament. The code for this is in method ShootOrnament():

If SpritesIntersect("TREE", "Ball" + OrnamentCount) Then
    PlaySound( HitSound )    
    // if we hit the tree count it and show it
    HitCount = HitCount + 1
    // calculate the ornament offset
    BallOffset[OrnamentCount] = BallX[OrnamentCount] - TreeX 
Else
    // if we miss the tree all together don't count or show ornament
    PlaySound( BreakSound )    
    HideSprite("Ball" + OrnamentCount)    

End If

Note that if we actually got the ornament on the tree, we figure out its Offset so we can later move it along with the tree. And if we miss the tree altogether, the bulb breaks and is not shown.

These ornaments are those fragile little glass balls—proof that guys have no business decorating Christmas trees, right?!? If we actually shoot one glass ball on top of another, well, they both break, Santa is less than pleased, and we might never get to open that green box! Here are the nested For...Next loops that check for this:

For Ornaments = 1 To OrnamentCount
    If Ornaments < OrnamentCount Then
        For OtherOrnaments = (Ornaments + 1) To OrnamentCount
            // Process balls hitting balls, don't count them and 
            // don't show them
            If SpritesIntersect("Ball" + Ornaments, "Ball" + 
                                 OtherOrnaments) Then
                PlaySound( OrnamentHit )
                HideSprite("Ball" + Ornaments)
                HideSprite("Ball" + OtherOrnaments)
                HitCount = HitCount - 2
            End If
        Next
    End If
Next

Besides nested loops always being fun exercises of logic, this is interesting because it shows how easy it can be to use an automatic type conversion to build a string from a number. Our sprites are named Ball1 to Ball5, and when we need to process them in a loop this way, we can simply construct the name by concatenating "Ball" + Ornaments, where the latter is the integer loop index.

Allowing user customization of game behavior

Besides being educational, open-source KPL games have the advantage of allowing a user to change or customize the game behavior. The entire game and all its code is there for the user's modification, but it's also worth putting a little thought and effort into allowing easy customization of the behavior of your game. Our Christmas Tree Shooter does this with three global variables, defined, commented and changeable up at the top of the program file:

// Set these next 3 variables to affect game play
Define CrossHairSpeed As Int = 20
Define TreeSpeed As Int = 20
// how many times the tree will move before game is over

Define MoveCount As Int = 2 // = once to the right, once to the left

Good naming and comments make this pretty easy for users to find and change. The two speed variables can be tweaked to make the game easier or harder, depending on the user's reflexes. And the move count can be increased to lengthen the game and allow the user more time.

Building in game settings based on global variables like this just takes a little thought, and can allow a fun extra level of control for people playing your game.

What's next?

Two or three other Holiday-themed KPL games should also be up on the Coding4Fun site. Have fun with them, and Happy Holidays—no matter which particular Holiday you're celebrating at this time of year!

KPL Asteroids is also next in the series of retro games implemented with KPL—watch for that in the next couple of weeks!

There are now dozens of open source KPL games, and dozens more educational programs—either included in the base KPL install, or new and separately downloadable. Check them all out at http://www.kidsprogramminglanguage.com/download.htm.

Moral of the story? Coding4Fun isn't just a name—it's the point!

Persistent Error Messages

Coding4Fun — Wed, 01 Nov 2006 08:49:00 GMT

	A prank that makes the hapless user see a familiar error message box that he/she can't close, and that spawns more and more error messages each time he/she try to close it.
Jacqueline Russell Difficulty: Easy Time Required: 3-6 hours Cost: Free Software: Visual Basic or Visual C# Express Editions Hardware: Download: Download

Here's a quick and easy prank that's sure to get a few laughs. I pulled this together in a matter of a few hours between meetings at work. It's very simple, so you should be able to quickly understand and customize it. Basically, on startup, the hapless user will see a familiar error message box that they can't close, and that spawns more and more error messages each time they try to close it. I tried this on my husband and it wasn't until the third error message box that he caught on!

To deploy

Simply copy the executable file (or a shortcut to it) to the Startup folder (C:\Documents and Settings\All Users\Start Menu\Programs\Startup) on the victim's machine and watch the fun begin when they start up their machine in the morning!

Ideas for Customization

Customize the text messages to your specific work situation or victim.
Add more forms.
If you're mean, don't allow the user to close the app at all and constantly rotate between forms.
For a more subtle approach, create a Windows service so that error messages pop up at random time intervals during the day and then disappear automagically (as soon as your victim gets Help Desk on the phone)!

Reusable Body Parts

Coding4Fun — Tue, 31 Oct 2006 08:39:51 GMT

Clint Rutkas

What screams Halloween more than fake body parts? Fake body parts that twitch and are covered with blood. The second thing that screams Halloween is causing some mischief.

Black cats of Hardware

I got to say, I love Phidgets. They are relatively inexpensive USB items that power motors and have a great API with tons of examples. My only issue I have is I follow what my teachers and mother told me far too much to the letter. I attempted to reuse and modify what I had instead of buying what I need to get the job done. After buying three separate items, I finally got the correct item for this task. I got a PhidgetMotorControl LV.

The failed purchase and why.

Attempt 1: The PhidgetTextLCD 8/8/8

Why did this Phidget fail to work for this application? It couldn’t provide enough power to the motor. The hand moved far more like something caught in a black hole than anything remotely scary.

Attempt 2: The Phidget Servo 4-Motor

My attempt to piggy back on top of a Servo control failed pretty badly. I forgot an important thing with servos which is they are always on. I got this initially for a different project and figured I could modify it to fit my need.

Mod the hand with internal water cooling!

Wait, no, I didn’t do that, but it would be cooler if I did. Getting the hand to work with the Phidget was rather easy. I soldered some extension wires into the battery pack and then hooked it into the Phidget.

Black cats of Hardware

This is a relatively easy program. Due to Phidget’s awesome and easy to use API, I had the program up and working in a matter of minutes. I spent more time messing around with the layout and finding a cool background than I did typing.

The entire application, in a c# power cord.

public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        MotorControl motor;
        
        private const string btnMoveStart = "Force Start Movement";
        private const string btnMoveEnd = "Force Stop Movement";

        private void Form1_Load(object sender, EventArgs e)
        {
            motor = new MotorControl();
            Servo_Detach(null, null);
            
            motor.Attach += new AttachEventHandler(Servo_Attach);
            motor.Detach += new DetachEventHandler(Servo_Detach);
            
            btnMove.Text = btnMoveStart;
            
            motor.open();
        }

        void Servo_Detach(object sender, DetachEventArgs e)
        {
            btnMove.Enabled = false;
            txtStatus.Text = "NOT CONNECTED";
            txtStatus.ForeColor = Color.Red;
        }
        private void Servo_Attach(object sender, AttachEventArgs e)
        {
            btnMove.Enabled = true;
            txtStatus.Text = "CONNECTED";
            txtStatus.ForeColor = Color.Green;
        }

        private void btnMove_Click(object sender, EventArgs e)
        {
            if (btnMove.Text == btnMoveStart)
            {
                btnMove.Text = btnMoveEnd;
                motor.motors[1].Velocity = 75;
            }
            else
            {
                btnMove.Text = btnMoveStart;
                motor.motors[1].Velocity = 0;
            }
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (motor.Attached)
                motor.close();
        }
    }

Now in a Visual Basic chord

Public Class Form1
    Inherits Form

    Private motor As MotorControl

    Private Const btnMoveStart As String = "Force Start Movement"

    Private Const btnMoveEnd As String = "Force Stop Movement"

    Public Sub New()
        MyBase.New()
        InitializeComponent()
    End Sub

    Private Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs) Handles MyBase.Load
        motor = New MotorControl
        Me.Servo_Detach(Nothing, Nothing)
        AddHandler motor.Attach, AddressOf Me.Servo_Attach
        AddHandler motor.Detach, AddressOf Me.Servo_Detach
        btnMove.Text = btnMoveStart
        motor.open()
    End Sub

    Private Sub Servo_Detach(ByVal sender As Object, ByVal e As DetachEventArgs)
        btnMove.Enabled = False
        txtStatus.Text = "NOT CONNECTED"
        txtStatus.ForeColor = Color.Red
    End Sub

    Private Sub Servo_Attach(ByVal sender As Object, ByVal e As AttachEventArgs)
        btnMove.Enabled = True
        txtStatus.Text = "CONNECTED"
        txtStatus.ForeColor = Color.Green
    End Sub

    Private Sub btnMove_Click(ByVal sender As Object, ByVal e As EventArgs) Handles btnMove.Click
        If (btnMove.Text = btnMoveStart) Then
            btnMove.Text = btnMoveEnd
            motor.motors(1).Velocity = 75
        Else
            btnMove.Text = btnMoveStart
            motor.motors(1).Velocity = 0
        End If
    End Sub

    Private Sub Form1_FormClosing(ByVal sender As Object, ByVal e As FormClosingEventArgs) Handles MyBase.FormClosing
        If motor.Attached Then
            motor.close()
        End If
    End Sub
End Class

Let the hunt begin for prank monkeys

Here is one of my favorite victims, Chris King, to prank.

Prank Video with motion hand

Conclusion

Hacking hardware is easy if you buy the right toys. What can be done to make this better and cooler? I could add in an IR sensor with the 8/8/8 and use that to detect if people are near the hand.

Author bio: Clint is an application developer for SpringCM, an on-demand, web-based document and content management system. As a developer, Clint is part of an innovative team committed to supporting affordable, scalable and reliable enterprise content management. His two primary development languages are C# and JavaScript. Prior to the Halloween Dead Hand project, he worked on his Disco Dance Floor. In his off time, he whips up other random weird projects and does twenty something activities with his friends. Clint’s blog is betterthaneveryone.com and can be emailed at clint@rutkas.com.

Scary Halloween Application

Coding4Fun — Tue, 31 Oct 2006 08:06:00 GMT

	Build an application that will drip animated blood down your victim's computer screen for a scary Halloween treat!
Brian Peek ASPSOFT, Inc. Difficulty: Easy Time Required: Less than 1 hour Cost: Free Software: Visual Basic or Visual C# Express Editions Hardware: None Download: Download Introduction

If you’re anything like me, and I hope for your friends’ and family’s sake you’re not, you believe that annoying others is amazingly entertaining. If that’s the case, then this article is for you.

We are going to build an application that you will copy to a friend’s PC that will, at a specified date and time, cause the computer to appear to start dripping blood down the screen and, after a few seconds, switch to a full-screen image of something terrifying while playing a screaming sound effect. This should sufficiently scare your victim for Halloween (hear the built-in scary sound).

The Form

We will be creating a full-screen, always-on-top, transparent form that will overlay the entire screen. This will be our display surface for the dripping blood.

The form can be created as described by modifying the following properties:

BackColor – Fuchsia

FormBorderStyle – None

DoubleBuffered – True

Text - <empty string>

WindowState – Maximized

ShowInTaskbar – False

TransparencyKey – Fuchsia

TopMost - True

This will create our full-screen, transparent form with no visible name, no icon in the task bar, no border that will remain on top of all other windows. With this in place, we can draw whatever we want to on to the form and it will be displayed over whatever happens to be on the screen. A nice bonus to this is that even though the form is maximized, because it is transparent, mouse and keyboard events will pass through to the visible active forms below. The user’s PC should act as though nothing is happening!

The Blood

I created a class named BloodDrop to represent the on-screen blood droplets flowing down the screen. When a droplet is instantiated, it loads its frames of animation from a series of images saved as resources in the application. Each image is located in a directory named images in the project, and its Build Action property is set to Embedded Resource.

With the images set as resources, we can load the images in the BloodDrop constructor as follows:

Visual Basic

Public Sub New()
    ' load each animation frame from the app's resources and add it to our frame list
    For Each file As String In _files
        Dim img As Image = Image.FromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream("HalloweenVB." + file))
        _frames.Add(img)
    Next

    ' set our first frame
    _image = _frames(0)
End Sub

Visual C#

public BloodDrop()
{
    // load each animation frame from the app's resources and add it to our frame list
    foreach(string file in _files)
    {
        Image img = Image.FromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream("Halloween.images." + file));
        _frames.Add(img);
    }

    // set our first frame
    _image = _frames[0];
}

The FromStream method of the Image object allows loading of an image file from an application’s embedded resource list. To get access to the stream for a specific resource, the name of the resource needs to be known, which is the fully qualified name of the file. In the case of the C# project, the resources are named Halloween.images.<filename>. The VB project’s resources are named HalloweenVB.<filename>. Though the images are stored in a directory named images in both projects, only the C# version includes the directory name as part of the fully qualified name.

In either case, each file is loaded and stored in a List of Image objects.

Drawing

At first, I experimented with making each blood droplet a PictureBox control and moving the control down the screen, but that was not quick enough for smooth animation. I next tried using a timer and drawing to the screen directly inside the Tick event, however this too was too jerky. Finally, I set the Tick event to simply invalidate the screen, causing the OnPaint event to fire. I found that performing screen updates inside this method with the DoubleBuffered property set to True allowed for the smoothest animation.

When the blood is set to be drawn, a timer is started that ticks every 100 milliseconds. This timer simply calls the Invalidate method of the current form object. When invalidated, the form calls its OnPaint handler, which we override.

Inside the OnPaint handler, we create a new BloodDrop object and assign a random horizontal position and vertical velocity to it. This provides for an interesting display as the blood drips down. The newly created BloodDrop is then added to a List of BloodDrop types. Finally, the full list of blood drops is enumerated, animated, and drawn.

Visual Basic

' create a new blood drop
Dim drop As BloodDrop = New BloodDrop()

' set it to a random location on the screen
drop.Location = New Point(_random.Next(SystemInformation.PrimaryMonitorSize.Width), 0)

' set it's velocity to a random number
drop.Velocity = _random.Next(40) + 20

' add it to our drawing list
_dropList.Add(drop)

' enumerate the drawing list
For Each bd As BloodDrop In _dropList
    ' animate and then draw the drop            
    bd.Animate()
    bd.Draw(g)
Next

Visual C#

// create a new blood drop
BloodDrop drop = new BloodDrop();

// set it to a random location on the screen
drop.Location = new Point(_random.Next(SystemInformation.PrimaryMonitorSize.Width), 0);

// set it's velocity to a random number
drop.Velocity = _random.Next(40) + 20;

// add it to our drawing list
_dropList.Add(drop);

// enumerate the drawing list
foreach(BloodDrop bd in _dropList)
{    
    // animate and then draw the drop            
    bd.Animate();
    bd.Draw(g);
}

At application startup, an instance of the Random class is created and stored in our _random member variable. The Next method requires a parameter for the maximum value of the random number to be returned. In the case of setting the drop’s location, I use the maximum screen width, determined by using the SystemInformation object. In the case of velocity, a maximum value of 40 pixels is requested, and an additional 20 pixels is added on in case a very low number is randomly selected.

Drawing the actual drop is pretty simple. The Draw method of our BloodDrop class looks like the following:

Visual Basic

' draw the drop
Public Sub Draw(ByVal g As Graphics)
    ' if we're in "drop" mode, draw the stream behind it
    If _index >= 4 Then
        g.DrawImage(_frames(4), Me._location.X + 24, 0, _frames(4).Width, Me._location.Y + 10)
    End If

    ' if we're beyond the bottom of the screen, don't bother drawing the drop
    If Me._location.Y < SystemInformation.PrimaryMonitorSize.Height Then
        g.DrawImage(_image, Me._location.X, Me._location.Y, _image.Width, _image.Height)
    End If
End Sub

Visual C#

// draw the drop
public void Draw(Graphics g)
{
    // if we're in "drop" mode, draw the stream behind it
    if(_index >= 4)
        g.DrawImage(_frames[4], this._location.X + 24, 0, _frames[4].Width, this._location.Y + 10);

    // if we're beyond the bottom of the screen, don't bother drawing the drop
    if(this._location.Y < SystemInformation.PrimaryMonitorSize.Height)
        g.DrawImage(_image, this._location.X, this._location.Y, _image.Width, _image.Height);
}

In each case, we use the Graphics object provided to us and use the DrawImage method to draw the correct frame number to the correct position. In order to save some CPU cycles, we first determine whether the drop has passed the lower edge of the screen and, if it is, it is not drawn. The size of the screen can be determined by using the SystemInformation object and using the PrimaryMonitorSize method.

The second part of this method draws the blood trail that follows behind the droplet as it falls. This is done by stretching an image that is 1 pixel tall down the screen to the top of the blood drop graphic.

In my first attempts at drawing the blood in this manner, I found that the DrawImage method, when scaling an image as it is doing here, will anti-alias and blend the image to make it appear less blocky. Unfortunately, this caused a great deal of distortion, making the trail look awful. After some experimenting, I found that setting the following properties of the Graphics object before drawing would allow the image to be stretched without modification.

Visual Basic

Protected Overrides Sub OnPaint(ByVal e As System.Windows.Forms.PaintEventArgs)
    ...
    ' grab the Graphics object for me app and set some properties for correct drawing
    Dim g As Graphics = e.Graphics
    g.PixelOffsetMode = PixelOffsetMode.Half
    g.InterpolationMode = InterpolationMode.NearestNeighbor
    g.CompositingQuality = CompositingQuality.HighSpeed
    ...
End Sub

Visual C#

protected override void OnPaint(PaintEventArgs e)
{
    ...
    // grab the Graphics object for this app and set some properties for correct drawing
    Graphics g = e.Graphics;
    g.PixelOffsetMode = PixelOffsetMode.Half;
    g.InterpolationMode = InterpolationMode.NearestNeighbor;
    g.CompositingQuality = CompositingQuality.HighSpeed;
    ...
}

The Finale

After the blood has dripped down the screen for several seconds (10 in the default case), the animation timer is disabled, the screen is cleared and a scary image is quickly displayed along with a loud screaming sound, which should hopefully scare the person at the keyboard. A running count of the time elapsed is stored in a member variable and is incremented by the timer’s Interval value each time our OnPaint method is called.

This is accomplished by creating a PictureBox on the fly and loading an image into the box. This box is then added to the Controls collection of the form and displayed. Additionally, two events are handled that will dismiss the application when a user clicks the mouse or presses a key on the keyboard.

The sound is then loaded from a resource and played using the SoundPlay object. This looks like the following:

Visual Basic

' disable the animation timer 
tmrAnim.Enabled = False

' create a Picturebox
Dim pb As PictureBox = New PictureBox()

' pull in the scary image from our resources
pb.Image = Image.FromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream("HalloweenVB.scary.jpg"))

' set it to fill the screen
pb.SizeMode = PictureBoxSizeMode.Zoom
pb.Width = SystemInformation.PrimaryMonitorSize.Width
pb.Height = SystemInformation.PrimaryMonitorSize.Height
pb.BackColor = Color.Black

' if it gets clicked, or someone presses a key, we want to end the app
AddHandler pb.Click, AddressOf pb_Click
AddHandler Me.KeyDown, AddressOf MainForm_KeyDown

' add the Picturebox to the controls list
Me.Controls.Add(pb)

' play a scary sound
Dim sp As SoundPlayer = New SoundPlayer(Assembly.GetExecutingAssembly().GetManifestResourceStream("HalloweenVB.scream.wav"))
sp.Play()

Visual C#

// disable the animation timer
tmrAnim.Enabled = false;

// create a Picturebox
PictureBox pb = new PictureBox();

// pull in the scary image from our resources
pb.Image = Image.FromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream("Halloween.images.scary.jpg"));

// set it to fill the screen
pb.SizeMode = PictureBoxSizeMode.Zoom;
pb.Width = SystemInformation.PrimaryMonitorSize.Width;
pb.Height = SystemInformation.PrimaryMonitorSize.Height;
pb.BackColor = Color.Black;

// if it gets clicked, or someone presses a key, we want to end the app
pb.Click += new EventHandler(pb_Click);
this.KeyDown += new KeyEventHandler(MainForm_KeyDown);

// add the Picturebox to the controls list
this.Controls.Add(pb);

// play a scary sound
SoundPlayer sp = new SoundPlayer(Assembly.GetExecutingAssembly().GetManifestResourceStream("Halloween.scream.wav"));
sp.Play();

As you can see, the sound and image resources are loaded in an identical manner as the frames of animation shown earlier.

The Scheduler

The final piece of the puzzle was to allow a user to select the date and time that the animation would start on the victim’s PC. I created a simple configuration dialog box that is displayed the first time the application is run. The dialog allows the person setting up the application to choose the date and time the animation should be fired. This is saved using the Settings object of the project. This way, the user can put the application in the startup group, or create a registry key to load it on startup, so if the PC is rebooted before the desired time is reached, the application will restart and wait for the time to occur.

Now, on application startup, the application’s Settings can be checked to determine if the configuration dialog needs to be shown, or just wait for the time specified.

When the application is started, a scheduler timer is created which ticks every minute. The Tick method for this timer looks at the current time, and if it is greater than or equal to the specified time, it will disable the scheduler timer, maximize the hidden window, and start the animation timer, which will automatically start drawing our blood droplets.

Visual Basic

Private Sub tmrScheduler_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles tmrScheduler.Tick
    If DateTime.Now >= My.Settings.Time Then
        ' re-maximize the window
        Me.WindowState = FormWindowState.Maximized

        ' disable me timer
        tmrScheduler.Enabled = False

        ' enable the animation timer
        tmrAnim.Enabled = True
    End If
End Sub

Visual C#

// called once per minute to check whether it's time to run the show
private void tmrScheduler_Tick(object sender, EventArgs e)
{
    // if the current time is greater than the time set by the user
    if(DateTime.Now >= Properties.Settings.Default.Time)
    {
        // re-maximize the window
        this.WindowState = FormWindowState.Maximized;

        // disable this timer
        tmrScheduler.Enabled = false;

        // enable the animation timer
        tmrAnim.Enabled = true;
    }
}

Deployment

As mentioned earlier, one of the main goals of this project was to have an extremely easily deployable application. In order to achieve this, all code was kept inside the framework with no dependencies on things like Managed DirectX. Additionally, all resources used by the application (images and sounds) were setup as embedded resources so they do not need to be deployed separately.

When you are ready to scare your friend, simply copy the Halloween.exe file to his or her PC. )You may want to enlist someone as the “lookout” so you don’t get caught while doing so!) Create a shortcut to it in the Startup program group, or set it up to run via the registry using the following key for the logged in user:

HKCU\Software\Microsoft\Windows\CurrentVersion\Run

Simply create a new string key with any Name, and a Data value of the path to the executable.

Summary

And there we have it. A very simple application requiring very little code that will elicit quite a reaction from your victim. The code can be very easily modified to include different images, a different sound effect, or even different animation effects. There is plenty of time between now and April Fool’s Day to modify the project for even more fun.

Thanks

A special thanks to Joey Buczek for drawing up the blood drop animation, Mark Zaugg for testing on a few machines outside my house, and Michelle Leavitt for making my writing a bit more palatable for the masses.

Bio

Motion-Detecting, Blood Squirting Halloween Skull

Coding4Fun — Tue, 31 Oct 2006 07:43:00 GMT

Create a scary surprise for your Halloween trick-or-treaters! With some off-the-shelf components and a bit of code, you can have some fun with your visitors...

Brian Peek

ASPSOFT, Inc.

Difficulty: Intermediate

Time Required: 1-3 hours

Cost: $100-$200

Software: Visual C# Express, Phidgets SDK

Hardware: AirLink101 AIC -250W wireless IP camera, Phidgets 0/0/4 Interface Kit, Westinghouse 3-Outlet Heavy Duty Remote, Beckett M60AUL Small Fountain Pump, rubber tubing, plastic skull, solder and soldering iron, external speakers

Download: Download

I wanted to build a small device that would terrify small children as they approached my door for Halloween. I suppose this makes me a bad person, but it’s still a lot of fun.

The concept here is pretty simple. We will be using motion detection from a web cam or network-enabled/IP camera to trigger a small fountain pump fitted into a bucket of water to spray anyone that approaches your front door. And, to make it a bit more creepy, we will fit the spray mechanism into a plastic skull.

WARNING: The pump being used will be connected to an A/C wall socket. While the pump is certainly designed to be used with water, please be aware of the fact that you will have water and electricity in close proximity to each other.

What You Will Need

A web or network-enabled camera. I am using the AirLink101 AIC-250W wireless IP camera.
A Phidget Interface Kit 0/0/4 – a USB-controlled board with 4 relays.
A remote-controlled A/C power outlet. I chose the Westinghouse 3-Outlet Heavy Duty Remote, Item #T28074, normally used for Christmas lights.
A fountain water pump. The one I used in this article is the Beckett M60AUL Small Fountain Pump. Almost any fountain pump will work, however be aware of how far the water will need to be pumped and choose a pump to meet your needs.
Rubber tubing of the appropriate size to fit the pump, preferably black if you can find it.
A Plastic Skull.
Red food coloring.
A soldering iron, solder and some spare wire.
A set of external speakers with an audio extension cable.
Optional: A strobe light.
Microsoft Visual C# 2005 Express Edition.

The Hardware

Let’s start by setting up the hardware. We will be using the remote controlled A/C outlet to toggle power to the pump at will. The remote control for the unit I purchased has a separate on and off switch, so we will wire one relay from the Phidget board to the on switch, and one relay to the off switch.

Open the remote control unit. Inside, you should see something similar to the image below:

Flip the unit over to access the side with the button contacts. My unit had two metal spring-type contacts taped to the board. Once removed, I was able to access the contacts directly. You should see contact pads similar to the following:

The pads each contain a common ground contact and an active contact. When the two are bridged, which happens when the button is pressed, the circuit closes and the remote sends the appropriate signal to the receiving unit. We will replicate the button action by tying a relay to each pad so that when the relay closes at our command, the circuit will close, sending the signal to the outlet unit.

Cut 4 equal lengths of wire and strip a bit of insulation off of each end. Carefully solder one end of each wire to each contact pad on the remote control as shown:

Additionally, use some electrical tape or rubber bands to affix the battery in place on the remote, if required.

Next, put the opposite end of each wire into the appropriate screw terminal on the Phidget relay board. You will notice on the Phidget board that there are 3 terminals per relay, labeled NO, XC, and NC, where “X” is a number from 0 to 3. These stand for “Normally Open”, “Relay X Common”, and “Normally Closed”. Since we want each circuit to be normally open, we will put one wire of each button to the NO terminal, and one to the XC terminal of each relay. For the on button, insert one wire into the NO terminal of relay 0, and one wire into the 0C screw terminal. Do the same with the wires from the off button, but wire them into relay 1. You should wind up with something looking like the picture below:

With this in place, we now have a computer-controlled remote control for the outlet. When the fountain pump (or anything else) is plugged into the outlet, it will toggle on and off as we open and close each relay.

Next, we will modify our plastic skull. If you have access to a real skull, feel free to use that instead. I decided to puncture a small hole in the bottom and drill a hole in the nose of the skull. I then fed the tubing through the nose hole and out of the bottom of the skull. You may also wish to run the tubing out of the eyes by either splitting the tubing near the eyes, or using two separate pumps plugged into the remote outlet.

Cut holes in the appropriate areas and push the rubber tubing through, leaving just a tiny bit hanging out of the exit hole.

Leave a generous amount of tubing coming out of the bottom of the skull. You will cut this later to the desired length once the prop is setup outside. When the gadget is later setup outside, you will fill a bucket with warm (or COLD!) water and add some food coloring, and the fountain pump. The pump I used submerges entirely in water, but yours may use an intake tube instead. Then, plug the pump into the remote controlled outlet, and plug the outlet into a standard A/C wall socket.

When the on signal is sent to the remote controlled outlet, the pump will turn on, and water will squirt from the rubber hose inside the skull!

Our skull is set to spray water out of its nose. Let’s set all of this aside for now and move onto the software side of things.

The Camera

For motion detection, I chose to use the AIC-250W wireless IP camera. This allows me to freely mount the camera wherever I wish and not worry about cords. Of course, it will require that you have a wireless access point somewhere nearby to connect the camera and the laptop together. You also could use an ad-hoc network with the camera, but I have not tested this. With the software we will be using, you also should be able to use a standard USB web camera. Regardless of the method chosen, please configure the camera appropriately so that the video output can be seen. In the case of the AIC-250W, it is as simple as running the included utility and setting it up to use your wireless network.

The Software

We will need several pieces installed before we can begin coding. First, ensure that you have Microsoft Visual C# 2005 Express Edition installed.

Following Scott Hanselman’s lead, I too will be using the excellent motion detection project from Andrew Kirillov.

Download the source code for this project, as we will be modifying what is there to meet our requirements.

You also will need to download and install the latest Phidget's library.

With those pieces installed and ready, we can begin modifying the software motion detection code.

I am not going to give you a tutorial of Andrew’s source code as that is done at the original site linked above. I suggest reading through that article and exploring the source code a bit to learn what’s going on behind the scenes. The code is somewhat complex in areas, however the project itself, along with the original article, are a fantastic learning experience.

Open the motion_src.sln file in Visual C# 2005 Express. When the solution is opened, the IDE will prompt you to upgrade the solution to the latest version. Accept the defaults and make your way through the wizard. When complete, you should see your solution with three projects loaded into the IDE.

The first thing we will add to the application is a handler to actually deal with firing the pump when the motion detection alarm is fired, which means we will need to communicate with the PhidgetInterfaceKit. Ensure the Phidget library listed above is installed. Then, right-click on the References folder in the motion project and select Add Reference… . Scroll down and select Phidget21.NET with runtime version 2.0.50727.

The pump is controlled in a separate thread, so we need to add the System.Threading library to our code along with the Phidget library. Finally, to play a loud sound through some external speakers, we need to use the System.Media library. All of this can be done by adding the following using statements to the top of our MainForm.cs code:

using System.Threading;
using Phidgets;
using Phidgets.Events;
using System.Media;

When motion is detected, we want to call a method that will turn the pump on for a bit and then turn it back off. After the pump has been activated, we also want it to wait for the user to click a button or press a button on the keyboard to setup the “trap” again. Otherwise, we run the potential of having the pump fire over and over again while handing out candy or before the “trick-or-treater” leaves. Alternatively, we can have the trap turn off for a specified period of time and then re-enable itself. We will discuss both methods.

First, add a bool variable named pumpOn to the MainForm class. This will maintain whether we are inside of our event handler, firing the pump.

private bool pumpOn = false;

Next, we need to create an instance of the InterfaceKit object to communicate with the Phidget board. Under the statement added above, add the following:

private InterfaceKit ifKit = new InterfaceKit();

Now that we have created an instance of the InterfaceKit object, we need to open communication with the device. In the MainForm constructor, after the call to InitializeComponent, add the following line:

// open the Phidget device
ifKit.open();

Next, look for a method named camera_Alarm in MainForm.cs. This is the event that is fired when motion is detected on the camera. Modify the camera_Alarm method to look like the following:

private void camera_Alarm( object sender, System.EventArgs e )
{
    // save movie for 5 seconds after motion stops   
    intervalsToSave = (int) ( 5 * ( 1000 / timer.Interval ) );

    if(!pumpOn)
    {
        Thread thread = new Thread(new ThreadStart(ActivatePump));
        thread.Start();
    }
}

This will, as long as the pump is not activated, spawn a new thread using the ActivatePump method. Add the following ActivatePump method to the MainForm class:

private void ActivatePump()
{
    pumpOn = true;

    // play the terrifying sound
    SoundPlayer sp = new SoundPlayer("scream.wav"));
    sp.Play();

    // press on switch, make sure off switch is not pressed
    ifKit.outputs[0] = true;
    ifKit.outputs[1] = false;

    // leave the pump on for 2 seconds
    Thread.Sleep(2000);

    // press off switch, make sure on switch is not pressed
    ifKit.outputs[0] = false;
    ifKit.outputs[1] = true;

    // hold it for half a second
    Thread.Sleep(500);

    // ensure no button is pressed
    ifKit.outputs[0] = false;
    ifKit.outputs[1] = false;

    try
    {
        // kill the current thread
        Thread.CurrentThread.Abort();
    }
    catch
    {
    }
}

This method will set our pumpOn variable to true and then create a new SoundPlayer object, loading the file scream.wav as an embedded resource. The scream.wav file should be from the same directory as the source code. The sound will then be played asynchronously using the Play method. Note that the scream.wav file located in the project solution is setup to be copied to the output directory on compilation. This can be done by selecting the file in the Solution Explorer and then choosing Copy always in the Copy to Output Directory option of the Properties window.

Next, we set the relays. Relay 0 (which is the On button if you wired as suggested above) is turned on while relay 1 (the Off button) is turned off. This is held for 2 seconds to allow the water to squirt out by putting the thread to sleep. Then, the relays are switched. The Off button is pressed (relay 1) and the On button is opened (relay 0). This is held for half a second, and then both relays are returned to their open positions. When this completes, we terminate our current thread so the process can begin again. Note that we wrap the call to Abort in an exception handler. When a thread is aborted, an exception is generated by the CLR. In this case we don’t care about the exception, so it is caught and thrown away.

At this point, you have two ways to handle resetting the software. One option is to add an additional Thread.Sleep call to the method above, wait for several minutes, and reset pumpOn to false:

...

ifKit.outputs[1] = false;

// wait two minutes
Thread.Sleep(120000);

pumpOn = false;

try
...

The other option is to add a button to the MainForm and set the pumpOn member variable to false when clicked. This will allow you to manually reset the effect after the candy has been handed out and the door is closed.

To do this, simply drag a button over to the MainForm, double-click it, and add the following to the generated Click event handler:

private void btnReset_Click(object sender, EventArgs e)
{
    pumpOn = false;
}

Running the Application

Press F5 to compile and run the application. When running, click on the File menu and choose the appropriate option to open the camera type you have. For the AIC-250W, we will be using the MJPEG URL option. You can connect to this camera with the following URL:

http://<camera’s IP address>/mjpeg.cgi

If everything has gone to plan, you should see the output from the camera show up in the center of the window.

The red lines around objects in the scene denote changes sensed by the software.

Final Tweaks

For my environment, I noticed that the motion detection alarm was a bit too sensitive. If you find the same, there is a simple modification you can make to decrease the sensitivity.

The level at which the alarm is set is determined by a private member variable inside the Camera class. If we expose that variable through a public property, we can then set that property when our application starts. By testing various values of this property, you should find one that is suitable for your area.

Open the Camera.cs file and add the following property to the code:

// AlarmLevel property
public double AlarmLevel
{
    get { return alarmLevel; }
    set { alarmLevel = value; }
}

Next, move back to the MainForm.cs file. Look for a method named OpenVideoSource. This method is where the Camera object is created. Right below the call to the Camera object’s constructor, add the following line, substituting a value that works for you:

// create camera
Camera camera = new Camera( source, detector );

// ADD: level at which alarm is fired
camera.AlarmLevel = 0.010;

For some additional fun, note that the Motion menu of the application contains an option to record video when motion is detected. With this checked, the application will write an AVI file out to its running directory when the alarm is fired…that is, when the scream is played and the blood is squired on your unsuspecting visitor!

Putting It All Together

The final setup is quite simple.

Fill up a bucket of water and add the red food coloring.
Submerge the pump (or the intake hose) into the water.
Hide the bucket behind a covered stand or inside a box.
Place the skull on top of the stand or box with the tubing running down into the pump’s output.
Plug the pump into the remote controlled A/C power outlet.
For some extra fun, plug a strobe light into the remote controlled outlet as well!
Plug that outlet into your outdoor power outlet, or run a cord to an outlet inside your home.
Configure and install the camera in an inconspicuous location near the skull and plug it into an outlet that isn’t the remote-controlled outlet. Make sure the camera is mounted sturdily so the camera doesn’t move and interfere with the motion detection.
Hide some external PC speakers near the skull and run the audio cable inside your home to your PC or laptop. (Make sure to turn up the volume!)
Back inside, plug the Phidget board (with the remote control connected to it ) into a USB port on your PC.
If you are using a wired camera of some sort, plug that in as well.
Run the application and wait for someone to approach the door!

When the software senses motion on the camera, the sound will play through the speakers and the relays will fire, turning on the outlet, which will fire the water pump. The “blood” will spray out of the skull and terrify the person outside that you’ve either a) just watched on the output screen, or b) recorded to an AVI file for later embarrassment. When you are ready to engage the gadget again, just click the “Reset” button and wait for the next visitor.

Conclusion

That’s all there is to it! With a bit of soldering and some off-the-shelf components, you can create a scary, fun, and wet surprise for your trick-or-treaters!