Here's some of our past terrifying short films...

Bug Killer

The Killer App

Kinect to Kill

Office 365 is here!

Ozzie Blogs! Rockin!

Oprah knows best

The dangers of re-tweeting

Happy Halloween!

That’s according to the Celts, who celebrated the festival of Samhain on October 31^st to mark the end of the “lighter half” of the year and start of the “darker half”. According to Wikipedia, the ancient Celts believed that the border between this world and the Otherworld became thin on Samhain, allowing spirits (both harmless and harmful) to pass through. The family's ancestors were honoured and invited home while harmful spirits were warded off. It is believed that the need to ward off harmful spirits led to the wearing of costumes and masks. Their purpose was to disguise oneself as a harmful spirit and thus avoid harm.

Nowadays, in many countries, Halloween is celebrated at the end of October, and if you and the family are preparing the apples for bobbing, pumpkins for carving, and costumes for wearing, or if you simply want to bring the spookiness of October to your desktop, then make sure you check out the Windows 7 Eerie Autumn theme.

Shiver at the sights of 15 creepy wallpapers, scream in terror at spooky sounds which greet every email and USB connection, but beware!  Gargoyles, gourds, and ghostly creatures haunt this eerily elegant Windows 7 theme.

Now where did I leave that cape?

Introduction

This article describes “Gremlin”, a quick and easy application that lets you play Halloween tricks. When your victim's computer is idle, Gremlin moves windows around on the screen, changes the focus window, moves your mouse, scrolls windows, and types nonsensical stuff. When there is background noise – like someone talking – it will shake the screen, even as your victim is typing away.

Deployment

Run it right away. You can download, copy theGremlin.exe executable and NAudio.dll to the victim's computer (say in c:\ directory), and then double click on the executable to run it.

Run it later. The other option is to copy the executable and dll files (or a shortcut to it) to the Startup folder on the victim's machine and watch the fun begin when they start up their machine in the morning!

If the computer you're using runs on Windows XP the path is:

C:\Documents and Settings\All Users\Start Menu\Programs\Startup

With Vista and Windows 7 the path looks like:

C:\Users\USERNAME\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup

Just remember to change USERNAME to the name of the user on your machine.

Commandline

Gremlin is compiled as a windows application, so it won't popup a terminal window if you double click on it, etc. But you can run it from the command line with flags:

-aggressive will make the gremlin's actions more obvious

-help will display the command line options

-name NAME is useful for testing. Gremlin will only use windows with this specific title or from this specific application. (Remember to drop the ".exe" from the application filename)

To stop the program, press CTRL+F2.

And now … the dodgy bits

The overall structure of the program is broken down into three kinds of functionality – actions, triggers and some interstitial glue:

Actions

• The screen-shaker is a window that makes the monitor look like it is shaking. Sort of like a loose cable on the back of the monitor.
• A random event might kick the windows around—either friction will slow them down, or...
• Gremlin will type nonsensical messages from the keyboard. These messages are then sent from a virtual keyboard, or they:
• Move the mouse around, or
• Press the mouse buttons, or
• Randomly switch the focus to another window

Triggers

• An audio module listens for sounds that trigger the module that shakes your screen.
• Otherwise, the software uses a p/invoke to GetLastInputInfo() and waits for the user to be idle for a minute or two. When it detects that the user is inactive, it randomly selects and carries out actions.

Other

• A hidden window receives key press events. I tend to reuse this module a lot, as a way to stop experimental programs that may have made my machine unusable.

For fun, I'll describe a couple of these modules below.

Screen shaker

My favorite bit is the screen shaker. It grabs a picture of the screens, creates a window that spreads across them, and then moves that image back and forth a few pixels every 30ms or so, with a little bit of random rotation. (Faster computers, of course, get a better effect).

The screen shaker is special in four ways:

• It is a top-level window – no other windows are allowed to go over it.
• This top-level window never becomes the focus window (the window that gets the keyboard events).
• Mouse button events (e.g. clicks and double-clicks) are passed through to the windows and desktop underneath. This gives the illusion that this is the "real" desktop shaking, by allowing a person to click on a button or text that passes the click thru to the real button or text.
• It shakes each of the monitor's screens independently

Some background: to create a window that looks like the shaking screen, I used two classes. The first is ScrShake (in ScreenShake.cs), which derives from the second class UnfocusableForm.  I'll describe ScrShake first.

The screen shaking process requires five instance variables:

• animTimer is a System.Windows.Forms.Timer used to force painting of a new frame on the screen.
• bx, and by are how far the screen has shaken up or down, left or right.
• angle is how much the screen has twisted during shaking.
• screenBitmap is an array of bitmaps, one for each of the monitors.

This creates a window without a border or other trappings, then makes it the topmost window and sets a flag in the method variable ExStyle to ignore mouse clicks. More on this flag in a little while.

C#

public partial class ScrShake : UnfocusableForm
{
   public ScrShake(double ShakeCoef, double AngleCoef) : base(true)
   {
      this.SuspendLayout();
      … other setup code …
      // This is needed since we're over the whole display, and we don't
      // want the other areas to be blurry
      TransparencyKey =  BackColor = ForeColor = System.Drawing.Color.Fuchsia;
      DoubleBuffered = true;
      TopMost = true;
      FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;

      ClientSize = new System.Drawing.Size(300, 300);
      Name = "topimage";
      ResumeLayout(false);

      // This is need to pass mouse clicks thru to lower layers
      ExStyle |= (int) WS . EX_TRANSPARENT;

      … More code that will be described later…
   }
}

When the timer has done a given number of animations, it will call the Stop() method. This will stop the animation, clean it up, and hide the window:

C#

void Stop()
{
   animTimer . Stop();
   Hide();
   screenBitmap = null;
}

When the main loops that start the animated screen shaking process, it calls the Screens() method. This grabs an image of the screens, determines the shape of each monitor, and starts the animation for 10 frames.

C#

internal void Screens()
{
   if (Visible)
   {
      Stop();
      return ;
   }
   // Grab the screens
   screenBitmap = Program.GrabScreens();
   CountDown = 10;

   animTimer.Start();
   angle = 0.0f;
   … code to display the window and get shape of monitors (see below)…
}

The screen capture portion is in ScreenCapture.cs. The method GrabScreens() creates an individual bitmap for each monitor and returns them as an array.

C#

internal void Screens()
{
   if (Visible)
   {
      Stop();
      return ;
   }
   // Grab the screens
   screenBitmap = Program.GrabScreens();
   CountDown = 10;

   animTimer.Start();
   angle = 0.0f;
   … code to display the window and get shape of monitors (see below)…
}

The code below determines the bounds of each screen and builds up a size of all of the screens put together. The window will be set to be this size.

C#

Screen[] AllScreens = Screen.AllScreens;

// full width/height of all monitors combined
Rectangle fullSize = AllScreens[0].Bounds;

// find a rectangle that will encompass all monitors on the system
// (assuming the primary monitor is on the left/top!)
for (int i = 1; i < AllScreens.Length && i < screenBitmap.Length; i++)
{
    Rectangle Bounds = AllScreens[i].Bounds;

    if (Bounds.Left < fullSize.Left)
        fullSize.X = Bounds.X;

    if (Bounds.Right > fullSize.Right)
        fullSize.Width = Bounds.Right - fullSize.X;

    if (Bounds.Top < fullSize.Top)
        fullSize.Y = Bounds.Y;

    if (Bounds.Bottom > fullSize.Bottom)
        fullSize.Height = Bounds.Bottom - fullSize.Y;
}

The code to show the window, fill the whole screen, and move it to the top looks like:

C#

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

// bring it to the top
BringToFront();

The constructor also created a timer that drives the screen shaking effect. The timer has a delegate that randomly selects the angle of rotation and the offset of the image, and triggers a repaint of the window. (The amount of shaking is controlled by two external variables called AngleCoef and ShakeCoef).

C#

animTimer = new System.Windows.Forms.Timer();
animTimer.Tick += delegate(object A, EventArgs E)
{
    if (--CountDown < 1)
        Stop();

    angle += (float)((Program.Rnd.NextDouble() - 0.5) * AngleCoef);
    bx = (float)((Program.Rnd.NextDouble() - 0.5) * ShakeCoef);
    by = (float)((Program.Rnd.NextDouble() - 0.5) * ShakeCoef);
    Invalidate();
};

// Sets the timer interval to 30 milliseconds.
animTimer.Interval = 30;

Although each monitor shifts up & down, left & right by the same amount, and rotates by the same angle, they are painted independently. This gives the illusion that each monitor has a shaky image. Paint the window is using the following code.

C#

protected override void OnPaint(PaintEventArgs e)
{
    base.OnPaint(e);
    Graphics g = e.Graphics;
    g.CompositingQuality = CompositingQuality.HighQuality;

    // for each monitor, draw the effect
    Screen[] AllScreens = Screen.AllScreens;
    for(int i = 0; i < screenBitmap.Length; i++)
    {
        if (null == screenBitmap[i])   continue;
        g.SmoothingMode = SmoothingMode.HighQuality;

        // grab the size of the current monitor
        Rectangle region = AllScreens[i].Bounds;

        double ImWidth = screenBitmap[i].Width  * 
           e.Graphics.DpiX / screenBitmap[i].HorizontalResolution;
        double ImHeight= screenBitmap[i].Height * 
           e.Graphics.DpiY / screenBitmap[i].VerticalResolution;
        Matrix m = new Matrix();
        m.Translate( (float)(- ImWidth  /2), 
                  (float)(- ImHeight /2), MatrixOrder.Append);

        // rotate the bitmap about the center
        m.RotateAt(angle, new Point(0,0), MatrixOrder.Append);

        // center the image no matter what its size is
        m.Translate( region.Width /2 - bx, 
                  region.Height/2 - by, MatrixOrder.Append);

        // assign our transformation matrix
        g.Transform = m;

        // draw it
        g.DrawImage(screenBitmap[i], region.Left, region.Top);
    }

The Form that does nothing!

The ScrShaker class uses a help class called UnfocusableForm (in UnfocusableForm.cs) to create a window that never becomes the focus window – it never receives key presses, etc.

This window has no trappings – no border, no resize gripper, no icon, no minimize / maximize buttons, no title bar.

C#

public partial class UnfocusableForm : Form
{
   public UnfocusableForm(bool X) : base()
   {
      if (X)
        {
           ControlBox = false;
           FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
           ShowInTaskbar = false;
           ShowIcon = false;
           MinimizeBox = false;
           SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
           StartPosition = System.Windows.Forms.FormStartPosition.Manual;
        }
   }

Then it overrides the ShowWithoutActivation method so that the window will not become the active when it is shown.

C#

protected override bool ShowWithoutActivation
{ get {  return true; } }

The UnfocusableForm class also overrides the CreateParams() method to set extra styles when creating the window. I haven't found a way to set these styles flexibly. Instead, the UnfocusableForm uses a method variable called ExStyle that allows derived classes to specify what flags they desire. In this case, The ScrShake class used the method variable to set a flag that ignore mouse clicks:

C#

protected override CreateParams CreateParams
{
  get
  {
     CreateParams cp=base.CreateParams;
     cp . ExStyle |= ExStyle;
     return cp;
  }
}

Finally, it captures a couple of events that ask a window if it would like to become the active window. (These usually happen when the user clicks on an inactive window):

C#

internal const int MA_NOACTIVATE = 0x0003;
protected override void WndProc(ref Message m)
{
  if (m.Msg == (int) WM.MOUSEACTIVATE)
  {
     m.Result = (IntPtr) MA_NOACTIVATE;
     return;
  }
  if (m.Msg == (int) WM.FOCUS)
  {
     m.Result = (IntPtr)1;
     return;
  }
  base.WndProc(ref m);
}

Sending Mouse Events

Sending Mouse Events is simple, but not trivial. The wiki at Pinvoke.net provides the signature to the procedures and structures we need to pass to it. (Note: these structures are a bit different, based on a blog posting by Raymond Chen)

C#

[DllImport("user32.dll", EntryPoint = "SendInput", SetLastError = true)]
static extern uint SendInput(uint nInputs, INPUT[] Inputs, int cbSize);
[DllImport("user32.dll", EntryPoint = "GetMessageExtraInfo", SetLastError = true)]
static extern IntPtr GetMessageExtraInfo();

[StructLayout(LayoutKind.Sequential)]
struct INPUT
{
   internal INPUTTYPE   type;
   internal INPUT_UNION i;
}

 // This generates the anonymous union
[StructLayout(LayoutKind.Explicit)]
struct INPUT_UNION
{
   [FieldOffset(0)]
   public MOUSEINPUT mi;
   [FieldOffset(0)]
   public KEYBDINPUT ki;
   [FieldOffset(0)]
   public HARDWAREINPUT hi;
};

[StructLayout(LayoutKind.Sequential)]
struct MOUSEINPUT
{
   public int    dx;
   public int    dy;
   public int    mouseData;
   public MOUSEEVENTF dwFlags;
   public int    time;
   public IntPtr dwExtraInfo;
}

[Flags]
enum MOUSEEVENTF : int
{
   MOVE       = 0x01,
   LEFTDOWN   = 0x02,
   LEFTUP     = 0x04,
   RIGHTDOWN  = 0x08,
   RIGHTUP    = 0x10,
   MIDDLEDOWN = 0x20,
   MIDDLEUP   = 0x40,
   ABSOLUTE   = 0x8000
}

Each of these pieces go together in a specific way. To do a mouse movement, a mouse event structure needs to be created. This involves setting dwFlags to the kind of mouse event (a relative movement in this case), dx and dy to the number of pixels moved. It is also important to set dwExtraInfo to whatever GetMessageExtraInfo() is set to.

C#

MOUSEINPUT MEvent = new MOUSEINPUT();
MEvent.dwFlags = MOUSEEVENTF.MOVE;
MEvent.dx = Rnd . Next(-8, 8) ;
MEvent.dy = Rnd . Next(-8, 8);
MEvent.dwExtraInfo = GetMessageExtraInfo();
Send(MEvent);

Sending the event takes a few more steps that are all wrapped in a helper methdo called Send(). Send these human interface device events via the SendInput() procedure (earlier). The procedure takes an array of events, for different kinds of devices. We have to create the array, set the event type, copy the event data, and then make the call:

C#

public virtual bool Send(MOUSEINPUT Event)
{
  INPUT[] Events = new INPUT[1];
  Events[0] . type = INPUTTYPE . MOUSE;
  Events[0] . i.mi = MEvent;
  return SendInput((uint)Events.Length, Events, Marshal.SizeOf(Events[0])) > 0; 
}

From here, sending a mouse button click is pretty straight forward. A mouse click is really a mouse button press event, followed by a mouse button release event. To make things interesting the mouse button is choosen at random. The “ugly” part is that each of the mouse buttons is assigned a bit, so a binary shift is used to convert a button number to its bit. And the button release is yet another bit, so the second message shifts the flags, to move the bit from the “button pressed” state to the “button released state”.

C#

MOUSEINPUT MEvent = new MOUSEINPUT();
MEvent.dwFlags = (MOUSEEVENTF) (1 << (2*Rnd.Next(0, 3)+1)) ;
MEvent.dwExtraInfo = GetMessageExtraInfo ();
Send(MEvent);

MEvent.dwFlags = (MOUSEEVENTF)((int) MEvent.dwFlags << 1);
MEvent.dwExtraInfo = GetMessageExtraInfo ();
Send(MEvent);

Generating deranged text

The gremlin can also type deranged sentences that will appear in editors, if the user left one open. The SendWait() method in the SendKeys class does the typing itself:

C# 

SendKeys . SendWait(GenerateSentence());
SendKeys . SendWait("{ENTER}");

Generating the sentences is not difficult; I used a simplistic Markov generator. This generator starts by randomly selecting a word that can start a sentence. The Starts variable is array which holds just these words. Then, in the Transition method, this word is used to find the next word that can be included in the sentence. It does this by using a dictionary, called NonStart, which given the word as a key, will return a list of all the words that can come after it. This process then repeats, appending the words onto the end of a string. It stops if it finds a word that can end a sentence.

C#

static Dictionary<string,string[]> NonStart ;
static string[] Starts;
static Dictionary<string,string> Terminal ;

static string GenerateSentence()
{
  StringBuilder SB = new StringBuilder();
  string Word = Starts[ Rnd.Next(0, Starts.Length) ];

  Transition(SB, Word);
  return SB.ToString();
}

static void Transition(StringBuilder SB, string Word)
{
  while (true)
  {
     SB.Append(Word);
     SB.Append(' ');

     // Look up word after this
     string[] Nexts;
     if (!NonStart.TryGetValue(Word, out Nexts))
       break;
     int Idx = Rnd.Next(Terminal . ContainsKey(Word) ? -1 :0, Nexts.Length);
     if (Idx < 0)
       break;
     Word = Nexts[Idx];
  }
}

Building these two dictionaries and array is a pretty simple process. The BuildSuffixTree() method takes a string and splits it up into sentences. Then it splits each sentence into (lower case) words. The first word of the sentence goes onto the end of the Starts array. Otherwise, the previous word is used to look up a list in a dictionary, and the current word is appended on to the list. This dictionary will become the NonStarts dictionary. The last word of the sentence is also placed into the Terminal dictionary, to indicate that this might be the end of a sentence.

C#

static void BuildSuffixTree()
{
  // First, build up a list of words that start sentence, and transitions
  List<string> Starts1 = new List<string>();
  Dictionary<string,List<string>> Trans = new Dictionary<string,List<string>>();
  foreach(string S1 in S.Split(new char[]{'.','?','!'}))
  {
     string Prev=null;
     foreach(string S2 in S1.Split(new char[]{' ','\n','\r','\t',',',';'}))
     {
        if (S2 . Length < 1)
          continue;
        if (null == Prev)
          {
             Starts1.Add(string.Intern(S2.ToLower()));
             Prev = string.Intern(S2.ToLower());
             continue;
          }
        List<string> Nextsa;
        if (! Trans.TryGetValue(Prev, out Nextsa))
          Trans[Prev] = Nextsa = new List<string>();
        Prev = string.Intern(S2.ToLower());
        Nextsa.Add(Prev);
     }
     if (null != Prev)
       Terminal[Prev] = Prev;
 }

 // Next, flatten the list of words that start a sentence
 Starts = Starts1.ToArray();

 // Flatten the transition table
 foreach (string S3 in Trans.Keys)
  NonStart[S3] = Trans [S3].ToArray();
}

The things that trigger action

The audio trigger

The audio module (in file AudioTrigger.cs) listens in on all of the microphones. It uses NAudio, with a basic setup and delegate structure swiped from Mark Heath's article “.NET Audio Recording”. The first difference is that it registers all audio input devices:

C#

static WaveIn[] StartMics()
{
  int NumDevices = WaveIn.DeviceCount;
  WaveIn[] AudIns = new WaveIn[NumDevices];
  for (int waveInDevice = 0; waveInDevice < NumDevices ; waveInDevice++)
  {
     AudIns[waveInDevice] = new WaveIn();
     AudIns[waveInDevice].DeviceNumber = waveInDevice;
     AudIns[waveInDevice].DataAvailable += waveIn_DataAvailable;
     AudIns[waveInDevice].WaveFormat = new WaveFormat(8000, 1);
     AudIns[waveInDevice].StartRecording();
  }
  return AudIns;
}

The real magic in the trigger is a modified version of the waveIn_DataAvailable delegate. Instead of saving the audio, it checks for any sound activity. It starts by checking to see if any of the sound amplitudes are greater than a pre-defined, very high threshold. Then the samples are squared and summed up, and the result is compared with a threshold. If it exceeds the threshold, the trigger is set. These two are good at catching the kind of sound made when a person is talking, futzing on the desk, or typing.

C#

static double AudioThresh  = 0.8;
static double AudioThresh2 = 0.09;

static void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
  bool Tr = false;
  double Sum2  = 0;
  int Count = e.BytesRecorded / 2;
  for (int index = 0; index < e.BytesRecorded; index += 2)
  {
     double Tmp = (short)((e.Buffer[index + 1] << 8) | e.Buffer[index + 0]);
     Tmp /= 32768.0;
     Sum2 += Tmp*Tmp;
     if (Tmp > AudioThresh)
       Tr = true;
  }
  Sum2 /= Count;

  // If the Mean-Square is greater than a threshold, set a flag to indicate that noise has happened
  if (Tr || Sum2 > AudioThresh2)
    Interlocked.Exchange(ref AudioTrigger, 1);
}

This sets a flag – AudioTrigger – which will be seen (and reset) in the main loop, with a bit of code that looks like:

C#

while (0 == Shutdown)
{
    // Do some lovely events
    Application . DoEvents();
    Thread . Sleep (20);

    //… do some other stuff ..

    // Check for a kick from the sound system
    if (0 != AudioTrigger)
    {
        Interlocked . Exchange(ref AudioTrigger, 0);
        …
        ScreenShaker . Screens();
        continue;
    }
    //… more checks for the user idle trigger…
}

Waiting for the user to be idle

The check to see if the user is not doing anything, the main loop uses a helper method called LastInputTime(), which returns the number of milliseconds the user did any input activity. The loop ensures that the user has been idle for long enough, and then calls the method that selects random gremlin actions:

C#

uint LastTime = Win32.LastInputTime();
if ((uint) Environment.TickCount < IdleTimeTrigger + LastTime)
    continue;

The LastInputTime() helper method uses a p/invoke call to the GetLastInputInfo() API call. The wiki at Pinvoke.net provides the signature to the procedure, and a suitable structure that we need to pass to it:

C#

[DllImport("User32.dll")]
static extern bool GetLastInputInfo(ref LASTINPUTINFO LastInfo);

[StructLayout(LayoutKind.Sequential)]
struct LASTINPUTINFO
{
  public uint cbSize;

  /// <summary>
  /// Number of system tickes
  /// </summary>
  public uint dwTime;
}

Then, these two structures are wrapped up into the LastInputTime() helper procedure, which does the dirty work of allocating and initializing a structure.

C#

internal static uint LastInputTime()
{
  LASTINPUTINFO lastInput=new LASTINPUTINFO();
  lastInput.cbSize = (uint)Marshal.SizeOf(lastInput);
  GetLastInputInfo(ref lastInput);
  return lastInput . dwTime;
}

Conclusion

The tricks gremlin plays are intended to be somewhat subtle. There is an aggressive option to make it react more, and move windows around more visibly.

If you want to try this out, the download link for the executable and source code are at the top of the article!

Resources and References

This article is a blatant grab bag of experimental and reused code from earlier experiments and other demo programs. Below are some of the projects I lifted code examples from:

• Pinvoke.net – a wiki-style site with many useful bits of example code related to calling the Windows API from within .NET.
• “.NET Audio Recorder” by Mark Heath, from which I stole code to make the audio trigger.
• “Possessed PC Pranks for Halloween” by Brian Peek, from which I stole the basic code for sending keystrokes.
• “April Fools' Day Application” by Brian Peek, from which I stole code to grab the screen and rotate it.

About The Author

Randall Maas writes firmware for medical devices, and consults in embedded software. Before that he did a lot of other things… like everyone else in the software industry. You can contact him at randym@acm.org.

Have you spent countless nights up late writing code?  Have your eyes burned after staring at a monitor for 18 hours? Have you ever wanted to hack up a co-worker or two?  Sure, we all have! Here’s the story of what happened to one developer on a dark and foggy night when the pressure was just too much…

Get the "Behind the Scenes" Theme here

	In this application, Brian Peek demonstrates how to create two spooky Halloween applications to trick your friends and colleagues.
Brian Peek ASPSOFT, Inc. Difficulty: Easy Time Required: Less than 1 hour Cost: Free Software: Visual Basic or Visual C# Express Editions, DirectX SDK (for application #1) Hardware: None Download: Download

Introduction

Last year I wrote two articles on how to annoy your friends and family by dripping blood down their computer screen, or by squirting them with (hopefully) fake blood from (even more hopefully) a fake skull.  Halloween is just around the corner, so here are two more applications which you can use to further bother the people around you.

Application #1 - Cursed Video

If you have ever seen the horror film The Ring, then you can likely guess the basic premise of this application.  For those that haven't, the film is about a video tape which, when watched, will cause the viewer to die within a week of viewing it.  So, what better way to annoy and terrify your friends than by playing the "cursed video" at a time you schedule without their knowing?

This application will use a library from Managed DirectX to play the video.  If you haven't already, grab the full DirectX SDK and install.  Note that we will be creating a dependency on DirectX, so the victim's PC will need to have DirectX 9.0c installed.  Almost every XP desktop has it installed at this point, but be sure to test the app on the target PC.  Additionally, I have had mixed success drawing a semi-transparent video with every method I've tried (DX, WPF, etc.).  It is very dependent on video drivers, so the intended effect may not be perfect on all PCs.  Again, be sure to test.

Next, create a new C#/VB Windows Application project and set references to the Microsoft.DirectX and Microsoft.DirectX.AudioVideoPlayback assemblies as shown:

Next, we need to make some modifications to the form.  The video will be played at 50% transparency against the victim's desktop, which gives a very creepy effect.  The form should also be hidden from view until the video is ready to be played at the selected time.  To do this, set the following properties on the form:

Next, we need to provide a surface onto which the video can be drawn.  Drop a PictureBox control onto the form and set its properties as follows:

Now we need a method which will play the video.  Bring in the Microsoft.DirectX.AudioVideoPlayback namespace with the using/Imports keyword and then add the following method to the form:

C#

using Microsoft.DirectX.AudioVideoPlayback;

...

Video _video;

public void StartShow()
{
    // create a new video from a filename
    this._video = Video.FromFile("ring.wmv");

    // set the drawable surface to the picturebox
    this._video.Owner = pictureBox1;

    // setup an event handler so we can pop up a msgbox when the video is over
    this._video.Ending += new EventHandler(video_Ending);

    // play it!
    this._video.Play();
}

void video_Ending(object sender, EventArgs e)
{
    // called when the video ends
    MessageBox.Show("Happy Halloween!");
    this.Close();
}

VB

Imports Microsoft.DirectX.AudioVideoPlayback

...

Private _video As Video

Public Sub StartShow()
    ' create a new video from a filename
    Me._video = Video.FromFile("ring.wmv")

    ' set the drawable surface to the picturebox
    Me._video.Owner = pictureBox1

    ' setup an event handler so we can pop up a msgbox when the video is over
    AddHandler _video.Ending, AddressOf video_Ending

    ' play it!
    Me._video.Play()
End Sub

Private Sub video_Ending(ByVal sender As Object, ByVal e As EventArgs)
    ' called when the video ends
    MessageBox.Show("Happy Halloween!")
    Me.Close()
End Sub

This simply creates a new Video object by loading a specific filename (ring.wmv), then assigns the video's Owner property to the PictureBox, which is where the video will be drawn.  Next, an event is setup so we are notified when the clip has ended, and finally, the video is played with the Play method.

The video_Ending event handler displays a message box and closes down the application.

x86/x64

The Managed DirectX assemblies are compiled to run in x86 mode only.  If you are compiling the application on an x64 OS, you will have to ensure that the main application is built as an x86 target.  To do so, choose Configuration Manager from the build menu.  In the dialog that appears, choose <New...> from the Active solution platform drop down:

Finally, choose x86 from the Type or select the new platform drop down:

Get back to the project and rebuild and you will have an x86-native application which will run successfully on both x86 and x64 platforms.

Config/Test/Scheduler

The code which handles the configuration, scheduling and testing will be the same for both of these applications, so please jump to that section by clicking here.

Application #2 - The Shining

If you have seen The Shining, you can probably guess where this one is heading, too.  The basic plot is that an author and his family retreat to an isolated hotel for the winter, and some paranormal activity causes the father to go a bit insane, among other things.  In the film, as the author goes crazy, he starts typing "All work and no play makes Jack a dull boy" over and over again on the typewriter.  So, this application will mimic that by, at the appointed time, popping up an instance of Notepad and having the computer type the phrase over and over again on its own.

Once again, create a new VB/C# Windows Application project.  As with the previous project, we want the main form to be hidden, but this time, it should be hidden at all times.  So, set the form properties as follows:

Next, drag a timer onto the form named tmrType and create an event handler for the Tick event which we will fill in later.

Create a method named StartShow as follows:

C#

using System.Diagnostics;
...

private Process _process;

public void StartShow()
{
    _process = Process.Start("notepad.exe");
    tmrType.Start();
}

VB

Imports System.Diagnostics

...

' the Notepad process
Private _process As Process

Public Sub StartShow()
    _process = Process.Start("notepad.exe")
    tmrType.Start()
End Sub

This code starts an instance of Notepad and then starts the tmrType ticking.  That tick event will send the appropriate letter to the Notepad window from the phrase:

C#

using System.Runtime.InteropServices;

...

[DllImport("user32")]
public static extern int SetForegroundWindow(IntPtr hwnd);

// counter variables
private int i, j;

// the message to type out
private const string msg = "All work and no play makes Jack a dull boy.";

...

private void tmrType_Tick(object sender, EventArgs e)
{
    // make sure the Notepad window is at the front
    SetForegroundWindow(_process.MainWindowHandle);

    // send the next letter to the window
    if(i < msg.Length)
        SendKeys.Send(msg[i++].ToString());
    else
    {
        // send a carriage return if we're at the end of the line
        SendKeys.Send("{ENTER}");

        // write the line 5 times
        if(++j < 5)
            i = 0;
        else
        {
            // when done, stop the timer, display the msgbox and close it up
            tmrType.Stop();
            MessageBox.Show("Happy Halloween!");
            this.Close();
        }
    }
}

VB

Imports System.Runtime.InteropServices

...

<DllImport("user32")> _
Public Shared Function SetForegroundWindow(ByVal hwnd As IntPtr) As Integer
End Function

' counter variables
Private i, j As Integer

' the message to type out
Private Const msg As String = "All work and no play makes Jack a dull boy."

Private Sub tmrType_Tick(ByVal sender As Object, ByVal e As EventArgs) Handles tmrType.Tick
    ' make sure the Notepad window is at the front
    SetForegroundWindow(_process.MainWindowHandle)

    ' send the next letter to the window
    If i < msg.Length Then
        SendKeys.Send(msg.Chars(i).ToString())
        i += 1
    Else
        ' send a carriage return if we're at the end of the line
        SendKeys.Send("{ENTER}")

        ' write the line 5 times
        j = j + 1
        If j < 5 Then
            i = 0
        Else
            ' when done, stop the timer, display the msgbox and close it up
            tmrType.Stop()
            MessageBox.Show("Happy Halloween!")
            Me.Close()
        End If
    End If
End Sub

At the start of the tick, a call is made to the Win32 API function SetForegroundWindow, passing in the window handle (_process.MainWindowHandle) of the Notepad process.  This ensures that the Notepad window is focused before we send the next letter to the window using the SendKeys method.  When the end of the phrase is reached, a carriage return is sent using SendKeys and the string {ENTER}.  This repeats 5 times at which point the timer is stopped, the message box is displayed, and the application closes.

The Scheduler

The final piece is to setup a time at which the effect will display on the victim's PC.  Create a simple dialog box with a DateTimePicker control that allows the choosing of the appropriate date/time to run:

Next, create a new application setting named Time as shown:

Next, setup the events on the Configuration form as follows:

C#

private void ConfigForm_Load(object sender, EventArgs e)
{
    // if no time has been specified, show today's date, otherwise, show the date previously selected
    if(Properties.Settings.Default.Time == DateTime.MinValue)
        dateTimePicker1.Value = DateTime.Now.Date;
    else
        dateTimePicker1.Value = Properties.Settings.Default.Time;
}

private void btnSave_Click(object sender, EventArgs e)
{
    // save the currently selected date/time to the Settings collection
    Properties.Settings.Default.Time = dateTimePicker1.Value;

    Properties.Settings.Default.Save();

    // tell the user what's up
    MessageBox.Show("Date and time saved.  When you click OK, the application will continue running and the show will start upon the specified date and time.  If you wish to reset the date/time, restart the application with the '-config' switch.", "Configuration updated", MessageBoxButtons.OK, MessageBoxIcon.Information);

    // close it up
    this.DialogResult = DialogResult.OK;
    this.Close();
}

private void btnCancel_Click(object sender, EventArgs e)
{
    // close it up
    this.DialogResult = DialogResult.Cancel;
    this.Close();
}

VB

Private Sub ConfigForm_Load(ByVal sender As Object, ByVal e As EventArgs) Handles MyBase.Load
    ' if no time has been specified, show today's date, otherwise, show the date previously selected
    If My.Settings.Default.Time = DateTime.MinValue Then
        dateTimePicker1.Value = DateTime.Now.Date
    Else
        dateTimePicker1.Value = My.Settings.Default.Time
    End If
End Sub

Private Sub btnSave_Click(ByVal sender As Object, ByVal e As EventArgs) Handles btnSave.Click
    ' save the currently selected date/time to the Settings collection
    My.Settings.Default.Time = dateTimePicker1.Value

    My.Settings.Default.Save()

    ' tell the user what's up
    MessageBox.Show("Date and time saved.  When you click OK, the application will continue running and the show will start upon the specified date and time.  If you wish to reset the date/time, restart the application with the '-config' switch.", "Configuration updated", MessageBoxButtons.OK, MessageBoxIcon.Information)

    ' close it up
    Me.DialogResult = System.Windows.Forms.DialogResult.OK
    Me.Close()
End Sub

Private Sub btnCancel_Click(ByVal sender As Object, ByVal e As EventArgs) Handles btnCancel.Click
    ' close it up
    Me.DialogResult = System.Windows.Forms.DialogResult.Cancel
    Me.Close()
End Sub

The code loads the current value at start (if it exists), saves it when the Save button is clicked, and does nothing when Cancel is clicked.

Back on the main form of either application, drag and drop a timer control named tmrScheduler to the main design surface.  Set the properties as follows:

This will start the timer immediately and call the Tick event once every minute.  That event will check to see whether the requested time has passed and, if so, starts the show:

C# - Cursed Video

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)
    {
        // bring up the window
        this.WindowState = FormWindowState.Maximized;

        // disable this timer
        tmrScheduler.Enabled = false;

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

        // play the movie
        StartShow();
    }
}

VB - Cursed Video

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
        ' bring up the window
        Me.WindowState = FormWindowState.Maximized

        ' disable this timer
        tmrScheduler.Enabled = False

        ' bring it to the top
        Me.BringToFront()

        ' play the movie
        StartShow()
    End If
End Sub

C# - The Shining

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)
    {
        // disable this timer
        tmrScheduler.Enabled = false;

        // start typing
        StartShow();
    }
}

VB - The Shining

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
        ' disable this timer
        tmrScheduler.Enabled = False

        ' start typing
        StartShow()
    End If
End Sub

Configuration/Testing

To make it easy to reset the launch time, and to test the effect without scheduling it, two command line parameters can be added to Program.cs/vb to re-run the configuration or test.  Add the following code prior to the call to Application.Run:

C#

// test the effect
if(Environment.CommandLine.IndexOf("test") > -1)
{
    Form1 f = new Form1();
    f.StartShow();
    f.ShowDialog();
    return;
}

// if we haven't set the time, or the user requested the config dialog, display it
if(Properties.Settings.Default.Time == DateTime.MinValue || Environment.CommandLine.IndexOf("config") > -1)
{
    if(new ConfigForm().ShowDialog() == DialogResult.Cancel)
        return;
}

VB

' test the effect
If Environment.CommandLine.IndexOf("test") > -1 Then
    Dim f As Form1 = New Form1()
    f.StartShow()
    f.ShowDialog()
    Return
End If

' if we haven't set the time, or the user requested the config dialog, display it
If My.Settings.Default.Time = DateTime.MinValue OrElse Environment.CommandLine.IndexOf("config") > -1 Then
    If New ConfigForm().ShowDialog() = DialogResult.Cancel Then
        Return
    End If
End If

If -test is passed on the command line, the form is created and the show is started.  If -config is passed on the command line, the Configuration dialog is displayed and the application continues as it would the first time it ran.

Deployment

Cursed Video

Copy the exe, Microsoft.DirectX and Microsoft.DirectX.AudioVideoPlayback to a folder on the user's PC along with a video clip named ring.wmv.  Of course, you can replace that video clip with any clip of your choosing, though if you wish to use a different filename, you will have to change the code and recompile.

The Shining

Copy the exe to a folder on the user's PC.

For either, 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.

Summary

Two Halloween applications for the price of one.  Not that you paid for either.  Be sure to have fun with them this Halloween and disturb anyone you can.  Enjoy!

Thanks

Thanks to Giovanni Montrone for testing out these applications during development.

Bio

Brian is a Microsoft C# MVP and 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, although 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/.

In this article I'll take you along for the ride as I attack the learning curve required to create a fun, interactive application using both the Microsoft Windows Presentation Foundation (WPF) and the Windows Communication Foundation (WCF). Afterwards, you'll have a flexible trivia client/server game ready to play by yourself or against friends, coworkers and your local know-it-all.  And in honor of Halloween, I've included three games of horror movie trivia.

Steve Holstad The Bright Lights Difficulty: Advanced Time Required: 6-10 hours Cost: Free Software: Visual Studio Express, 2005, 2008 Beta 2 Microsoft .NET Framework 3.0 Hardware: Download: Download Source

What can YeahTrivia do for me?

Glad you asked. This project started when I decided I wanted to dive headfirst into learning WPF and WCF, without hacking through countless Hello World examples.  And I wanted something fun that I could improve over time as my skills developed in these new technologies.  In this article I'll take you along for the ride as I attack the learning curve required to create a fun, interactive application using both the Microsoft Windows Presentation Foundation (WPF) and the Windows Communication Foundation (WCF). Afterwards, you'll have a flexible trivia client/server game ready to play by yourself or against friends, coworkers and your local know-it-all.  And in honor of Halloween, I've included three games of horror movie trivia.

In case you were wondering, the "YeahTrivia" name honors my new bride & her favorite prefix.  Think of it as YeeeeaaaaahhTrivia!

Basic Setup

This demo project was built using Visual Studio 2008 Beta 2, and is based on the Microsoft .NET Framework version 3.0.  The game is fed by a small windows app that acts as a game server, providing game selection, user registration, question loading, response times, chat messaging and scorekeeping.  The server loads a game by reading a predefined XML format, which we will look at a bit later.  This dynamic load lets anyone create their own flavor of trivia game, with any number of questions.

The server app exposes one WCF endpoint, a wsDualHttpBinding channel that supports duplex (two-way) communication between the server and any number of game clients.  Clients attach themselves to this endpoint and provide a callback address to the server.  The server saves an instance of this callback channel and uses each client's instance to contact the clients en masse during general game flow.  Enough talk, here's how to build one yourself.

Trivia Common and WCF Service Interfaces

The TriviaCommon project provides both the server and client projects access to shared objects.  To keep things simple the Common project only contains two classes:

Constants.cs defines the AnswerItem enumeration, which gives easy access to the five answer options (None, A, B, C, D), and the QuestionItem struct.  This structure is delivered to the client and contains question text, answer text, and the correct answer object of type AnswerItem.  Notice that objects being directly passed over the wire need to be marked with the [DataContract] attribute.

The second class, Interfaces.cs is where our WCF fun begins.  Take a look:

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Text;

namespace Trivia.Common
{
    #region Interfaces

    #region Service Interface

    /// <summary>
    /// Interface that defines Trivia service contract.
    /// </summary>
    [ServiceContract(CallbackContract = typeof(ITriviaCallback))]
    public interface ITrivia
    {
        [OperationContract(IsOneWay = true)]
        void RegisterUser(string userName);

        [OperationContract(IsOneWay = true)]
        void AcceptAnswer(string userName, string answerValue);

        [OperationContract(IsOneWay = true)]
        void ChatPublish(string userName, string message);
    }

    #endregion Service Interface

    #region Client Callback Interface

    /// <summary>
    /// Interface that defines Trivia client callback contract.
    /// </summary>
    public interface ITriviaCallback
    {        
        [OperationContract(IsOneWay = true)]
        void OnGameStart(int questionCount);

        [OperationContract(IsOneWay = true)]
        void OnGameEnd();

        [OperationContract(IsOneWay = true)]
        void OnUserRegistered(string userName);

        [OperationContract(IsOneWay = true)]
        void OnPublishChat(string userName, string chatMessage);

        [OperationContract(IsOneWay = true)]
        void OnQuestionLoad(int questionIndex, QuestionItem questionItem);

        [OperationContract(IsOneWay = true)]
        void OnQuestionEnd();

        [OperationContract(IsOneWay = true)]
        void OnQuestionStatusUpdate(Int64 questionTimeRemaining);

        [OperationContract(IsOneWay = true)]
        void OnScoreboardUpdate(Dictionary<string, Int64> scoreboard);

        [OperationContract(IsOneWay = true)]
        void OnGameServerStopped();
    }

    #endregion Client Callback Interface

    #endregion Interfaces
}

VB:

Imports System
Imports System.Collections.Generic
Imports System.ServiceModel
Imports System.Text

Namespace Trivia.Common

#Region "Interfaces"

#Region "Service Interface"
    
    ''' <summary>
    ''' Interface that defines Trivia service contract.
    ''' </summary>
    <ServiceContract(CallbackContract:=GetType(ITriviaCallback))> _
    Public Interface ITrivia
        <OperationContract(IsOneWay:=True)> _
        Sub RegisterUser(ByVal userName As String)

        <OperationContract(IsOneWay:=True)> _
        Sub AcceptAnswer(ByVal userName As String, ByVal answerValue As String)

        <OperationContract(IsOneWay:=True)> _
        Sub ChatPublish(ByVal userName As String, ByVal message As String)
    End Interface
        
#End Region

#Region "Client Callback Interface"

    ''' <summary>
    ''' Interface that defines Trivia client callback contract.
    ''' </summary>
    ''' <remarks></remarks>
    Public Interface ITriviaCallback
        <OperationContract(IsOneWay:=True)> _
      Sub OnGameStart(ByVal questionCount As Integer)

        <OperationContract(IsOneWay:=True)> _
        Sub OnGameEnd()

        <OperationContract(IsOneWay:=True)> _
        Sub OnUserRegistered(ByVal userName As String)

        <OperationContract(IsOneWay:=True)> _
        Sub OnPublishChat(ByVal userName As String, ByVal chatMessage As String)

        <OperationContract(IsOneWay:=True)> _
        Sub OnQuestionLoad(ByVal questionIndex As Integer, ByVal questionItem As QuestionItem)

        <OperationContract(IsOneWay:=True)> _
        Sub OnQuestionEnd()

        <OperationContract(IsOneWay:=True)> _
        Sub OnQuestionStatusUpdate(ByVal questionTimeRemaining As Long)

        <OperationContract(IsOneWay:=True)> _
        Sub OnScoreboardUpdate(ByVal scoreboard As Dictionary(Of String, Long))

        <OperationContract(IsOneWay:=True)> _
        Sub OnGameServerStopped()

    End Interface

#End Region

#End Region

End Namespace

A few items of interest here.  Notice we're importing the System.ServiceModel namespace.  This is the key assembly when using WCF, so don't forget to add a reference to your project.  The first interface, ITrivia, defines the operations the server is required to implement, which handle basic user actions: Register a team, accept an answer and accept a chat message.  Easy.

The second interface, cleverly named ITriviaCallback, lays out the callback contract a client must fulfill in order to play nicely with our server.  The operations listed here describe events the server will publish.  These aren't actual events, but the naming convention "OnX..." helps you remember that these are server published activities.

Notice that the [OperationContract] attribute notifies WCF that each method is part of a service contract.  The IsOneWay flag gives us "fire-and-forget" behavior (the app shouldn't wait around for a response).  So now that the common objects are ready, let's move on to...

Building the Trivia Server

The YeahTrivia Server is a simple utility app, but don't let the plain looks fool you; I thought about calling this the BrainStumper Pumper, but this is a family site.  This app lets a user (anyone acting as game admin) start the service, select the desired game, await team registrations, and then start the game.  If this were to become a larger scale project, I would make this an IIS hosted service that manages multiple games and provides more autonomy.  Until those sports bar royalty checks start rolling in, however, a utility app will do just fine.

The only form, GameServerDashboard, simply provides user interaction with the GameServer class.  On startup, the form inits an instance of GameServer and tells it to start the service.  It also loads all trivia question sets from the Games directory, and displays them in the list.

GameServer is the brain behind YeahTrivia. The attributes below set up the GameServer for action:

C#:

[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Reentrant
        ,InstanceContextMode = InstanceContextMode.Single)]
    public class GameServer : ITrivia

VB:

<ServiceBehavior(ConcurrencyMode:=ConcurrencyMode.Reentrant, InstanceContextMode:=InstanceContextMode.Single)> _
    Public Class GameServer
        Implements ITrivia

ConcurrencyMode.Reentrant prevents deadlocks between the apps by stating that while this service is single-threaded, callbacks are allowed to invoke new operations.

InstanceContextMode.Single sets the service as a singleton, so that all messages are delivered to the same object instance.

These are advanced topics if you're new to WCF, so I'll include some links at the end that helped clarify some of this for me.  Let's keep moving forward by looking at a few activities of the game server:

Start the Service:  Passes in the configured base address as a Uri, inits and opens a new ServiceHost.

C#:

public void StartService()
{
   // Set base address and open service host
   Uri baseAddress = new Uri(ConfigurationManager.AppSettings[CONFIG_KEY_BASEURI]);
   _serviceHost = new ServiceHost(new GameServer(), baseAddress);
   _serviceHost.Open();
}

VB:

  Public Sub StartService()
     'Set base address and open service host
     Dim baseAddress As New Uri(ConfigurationManager.AppSettings(CONFIG_KEY_BASEURI))
     _serviceHost = New ServiceHost(New GameServer(), baseAddress)
     _serviceHost.Open()
  End Sub

Register a new team: Saves off the callback, adds it to the callback collection and scoreboard containers, notifies the user of a successful registration, and notifies all game clients of the new team.

C#:

 public void RegisterUser(string userName)
 {
     _currentCallback = OperationContext.Current.GetCallbackChannel<ITriviaCallback>();

     // Store callback
     if (!_callbacks.ContainsKey(userName))
     {
         _callbacks.Add(userName, _currentCallback);
         _scoreboard.Add(userName, 0);

         // Notify user of registration
         _currentCallback.OnUserRegistered(userName);

         // Notify clients of new user
         foreach (string userKey in _callbacks.Keys)
         {
            _currentCallback = _callbacks[userKey];
            _currentCallback.OnPublishChat(GAME_USERKEY, string.Format(FORMAT_USER_REGISTERED, userName));
         }                
     }
     else
     {
         // User already registered, throw exception
         throw new Exception(ERROR_USER_ALREADY_EXISTS);
     }
 }

VB:

Public Sub RegisterUser(ByVal userName As String) Implements ITrivia.RegisterUser
   _currentCallback = OperationContext.Current.GetCallbackChannel(Of ITriviaCallback)()

   'Store callback
   If Not _callbacks.ContainsKey(userName) Then
      _callbacks.Add(userName, _currentCallback)
      _scoreboard.Add(userName, 0)

      'Notify user of registration
      _currentCallback.OnUserRegistered(userName)

      'Notify clients of new user
      For Each userKey As String In _callbacks.Keys
         _currentCallback = _callbacks(userKey)
         _currentCallback.OnPublishChat(GAME_USERKEY, String.Format(FORMAT_USER_REGISTERED, userName))
      Next
   Else
      'User already registered, throw exception
      Throw New Exception(ERROR_USER_ALREADY_EXISTS)
   End If
End Sub

You can start to see how the server is able to handle incoming calls and process them back to the clients using the duplex channel.  I'll leave the rest of the server actions for you to examine on your own.

Building the Game Client (WCF)

Address, Binding, Contract.  These are the ABC's of WCF.  The client's app.config file handles connecting to the service and specifying the channel and contract used to interact with it.  Examine the client portion of the client .config:

<client>
   <endpoint address="http://localhost:8088/Trivia" binding="wsDualHttpBinding"
      bindingConfiguration="WSDualHttpBinding_ITrivia" contract="Trivia.Common.ITrivia"
      name="WSDualHttpBinding_ITrivia">
   </endpoint>
</client>

The address points to the exposed service endpoint.  The binding sets the channel as "wsDualHttpBinding" (our http duplex channel).  The bindingConfiguration attribute is an optional pointer to another group of configurations for the binding, and finally, the contract sets the interface with which our client will be interacting.

Next it's time to generate a proxy class.  Memorize this: Svcutil.exe is your friend.  The client needs a proxy class that it can use to interact with the service model.  The utility is a bit tricky at first, because of the wealth of optional flags, but stick with it, it's better than coding the proxy class by hand!  You can generate your client code by starting the service and running a command line similar to this:

svcutil /language:cs /out:ServerProxy.cs http://localhost:8088/Trivia

Add the generated class to the client project and you can begin to interact with the service.  The svcutil is available as part of the Windows SDK.  Check out the referenced site below for more information on this handy utility.

Building the Game Client (WPF)

Building the WPF portion of the client app was really a learning experience, and it will be the priority for me to improve in a later version.  Learning to program in XAML markup can seem daunting, and it requires a large paradigm shift on your part in order to grasp the new concepts.  Microsoft Expression is powerful tool for XAML work, but this time I coded all of the XAML by hand in order to fully see what was taking place inside.

A deep discussion of WPF is beyond the scope of this article, but take a look at the example code to get an idea of the layout.  An excellent book to start with is WPF Unleashed by Adam Nathan.  An easy read (for a programming book), and solid examples to get you rolling.

I've set up the client using a instance of the Window class, which is shown below:

<Window x:Class="Trivia.Client.GameClient"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="YeahTrivia" MinHeight="620" MinWidth="620" 
    WindowStartupLocation="CenterScreen" WindowState="Normal"  Style="{DynamicResource MainWindowStyle}"
    Background="{DynamicResource MainWindowBackgroundBrush}">

The window class sets up the outermost container of the app, and includes two default namespaces.  I've also set a few other properties here: a min height and width, window startup location & state, and two styling attributes set by dynamic resources.

Resources are a great way to further separate form & function, allowing a programmer to handle the behavior of an app, while a designer can work simultaneously on the look, all without stepping on too many toes.  As a 2.0 task for this project, I would remove all inline styling and move them into resource dictionaries.  A dictionary contains styles and control templates (a skin) that can be loaded & switched at runtime.

ResourceDictionaries are linked to your XAML in the App.Xaml file.  Once you've set up the reference, the example above show how to reference the current dictionary:  The Background and Style properties are set as dynamic resources by naming the Keys specified in the ResourceDictionary (DefaultResources.xaml):

<LinearGradientBrush x:Key="MainWindowBackgroundBrush" StartPoint=".45,.45" EndPoint=".55,.55" SpreadMethod="Reflect">
   <GradientStop Offset="0" Color="DodgerBlue"/>
   <GradientStop Offset=".8" Color="DarkSlateBlue"/>
</LinearGradientBrush>

<Style TargetType="{x:Type Window}" x:Key="MainWindowStyle">
   <Setter Property="FontFamily" Value="Trebuchet MS"/>
</Style>

Not quite as easy as CSS, but for a Forms project, it's a nice feature.  The sample ResourceDictionary includes a button control template for all of my buttons, based on Rob Eisenberg's excellent article (link below).

One other interesting feature to point out: Take a look at the code-behind class MarshalToUIThread method, which accepts a SendOrPostCallback parameter.  This is where the client is transferring actions from the sync thread back to the UI thread.  In each interface method implementation (OnX..), you can see how I wrap any UI-directed code and assign it to the postCallback field.  Passing this to the MarshalToUIThread method simply issues a SynchronizationContext.Post call, and the UI thread executes as expected.

Creating a New Trivia Game (XML)

New trivia games can be added at any time using the simple XML format shown here.  After installing the server application, simply drop the new .XML file into the Games directory ([Server Install Location]\Yeah Trivia Server\Games).  This demo comes pre-loaded with Geek Trivia, and a special Halloween Trivia version in case you're feeling festive.

<TriviaQuestionDataSet xmlns="http://tempuri.org/TriviaQuestionDataSet.xsd">
  <TriviaQuestion>
    <QuestionText>Name the highest grossing Monty Python creation.</QuestionText>
    <AnswerTextA>A) Holy Grail</AnswerTextA>
    <AnswerTextB>B) The Life of Brian</AnswerTextB>
    <AnswerTextC>C) Shrubbery</AnswerTextC>
    <AnswerTextD>D) The Meaning of Life</AnswerTextD>
    <CorrectAnswerKey>A</CorrectAnswerKey>
  </TriviaQuestion>
  <TriviaQuestion>
    <QuestionText>Ferris Bueller's best friend was _________.</QuestionText>
    <AnswerTextA>A) Sloane Peterson</AnswerTextA>
    <AnswerTextB>B) Edward R. Rooney</AnswerTextB>
    <AnswerTextC>C) Charlie Sheen</AnswerTextC>
    <AnswerTextD>D) Cameron Frye</AnswerTextD>
    <CorrectAnswerKey>D</CorrectAnswerKey>
  </TriviaQuestion>
</TriviaQuestionDataSet>

It's Time to Play YeahTrivia

Install both the Server and Client applications.  First, fire up the server, and then start your game client(s).  Once everyone has registered a team, select your game and hit "Start Game".    You're off...

Game Over

So there you have it.  We've seen how WCF manages communication between objects, extracting complicated service protocols away from your code.  And just a small subset of the WPF functionality has shown us how quickly a rich, XAML-based UI can come together.  And maybe, just maybe, you've learned why a CD is 74 minutes long... but I'm not telling.

I challenge you to improve on this initial version of YeahTrivia:  Crack open the XAML and add animations, images, video, music & more.  Create a self-maintaining server to run multiple games at once.  Add a High Score storage system.  Extend the WCF settings to enable other communication channels.  Add a new skin. Create new question files to share with us.  Whatever you do, have fun and go nuts.  YeahCoding4Fun.

Download source files

Download compiled demo (C# and VB)

About The Author

Steve Holstad works as a software consultant for Clarity Consulting in Chicago.  He blogs at The Bright Lights, and is available via email at sholstad@claritycon.com

References

wcf.netfx3.com/
wpf.netfx3.com/
Generating a client proxy class
ConcurrencyMode
SvcUtil.exe Tutorial
Rob Eisenberg's WPF control template

Special thanks to Bryan Dougherty for the WCF jumpstart, Kevin Marshall for the Halloween Trivia and Jay Garmon, creator of TechRepublic's Geek Trivia.

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.

	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

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

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.

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.

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, 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.

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.

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

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/.

	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.

1. Fill up a bucket of water and add the red food coloring.
2. Submerge the pump (or the intake hose) into the water.
3. Hide the bucket behind a covered stand or inside a box.
4. Place the skull on top of the stand or box with the tubing running down into the pump's output.
5. Plug the pump into the remote controlled A/C power outlet.
6. For some extra fun, plug a strobe light into the remote controlled outlet as well!
7. Plug that outlet into your outdoor power outlet, or run a cord to an outlet inside your home.
8. 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.
9. 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!)
10. Back inside, plug the Phidget board (with the remote control connected to it ) into a USB port on your PC.
11. If you are using a wired camera of some sort, plug that in as well.
12. 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!

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/.