Automatic Cold Frame Hinge

The goal of this project is to create a powered hinge for a cold frame or green house that automatically opens and closes based on temperature. An arduino was used for the control board to read the temperature sensor and instruct the servo motors when to operate.

Parts Used:

  • Arduino Uno or Nano
  • Servo Motor
  • 100 uF capacitor
  • 4.7k Ohm Resister
  • DS18B20 Temperature Sensor
  • I2C OLED Screen
  • 10K Potentiometer

Arduino Wiring Diagram

First prototype

3D Model of version 2


2D Top Down Action RPG

2D level creation with Cellular Automata and Connected Component Labeling

Worlds are generated with multiple zones and levels inside. Each level is created using Cellular Automata techniques to generate the solid parts of the terrain. Levels are currently only rectangular in size, and each level has multiple paths/doors to other levels. These paths are created randomly within a tree like structure.

Level Creation Steps:

  1. Run Cellular Automata Logic
  2. Create Border Walls
  3. Find all Open Spaces via Connected Component Labeling
  4. Create Border Doors
  5. Ensure all open spaces are accessible by the player
  6. Ensure all border doors are also accessible.

To ensure that all doors on the levels are accessible to the player, A Star path finding techniques are used after level boundaries are created and cellular automata logic is run. A Star is run between each pair of doors within a level, with weights on solid cells of the grid being very large, causing the path finding to travel through already opened areas created via the cellular automata. If a door is not accessible the path finding will remove solid cells to ensure accessibility.

Connected Component Labeling was used to ensure that all open/non solid areas of the level are accessible. Each connected open space is checked against its neighbors to ensure it is accessible by the player, path finding is then used to create a path if needed.

Goal-Driven Agent Behavior for Enemy Control

Enemy Behavior was created with a design pattern found in the book Programming Game AI by Example . This allowed each enemy to have emergent behavior based on various goals and conditions of the game world. Goals and actions included keeping rooms cleared of enemies, avoiding attacks, seeking out health, etc.



Spaceship Building and Command RTS Game

Game concept: Starting with a base mothership that allows the player to create collector ships to collect resources. With these resources, ship attachments can be made including defensive systems, weapons, armor, fuel, batteries, etc. Ships are limited by the power generation, create a challenge to manage building out the ship, traveling to collect resources, firing weapons, and high speed assault maneuvers.

Techniques Used:

  • Goal-Driven Agent Behavior for enemy movement and ship construction
  • Messaging to support disparate game actor communication with Goal-Driven Agents
  • Object Pooling for projectiles
  • Unity’s Physics and collision detection to support movement, collisions, and ship building.



Side Scroller Action Shooter

Techniques Used:

  • Object Pooling for projectiles and short lived objects.
  • Different camera logic for levels to provide a different feel.
    Locked camera for boss fights and puzzle areas.
    Moving camera for long exploratory areas.
    Camera on “rails” that ensures camera moves with player but stays within level bounds to give a more predictable camera location, and prevent excessive dead areas on screen.
  • Custom built character controller to get very precise 2D movement.
  • Parallax Image techniques to show movement on 2D landscape.


Electric Bike Build

Built battery pack with 18650 cells in 14 serial 8 parallel configuration driving a Bafang mid drive kit.


Retrieve parameterized triggered build display name with groovy script

Using the groovy plugin and Jenkins Parameterized Trigger plugin, we can create a groovy script that retrieves the previous triggered build number from the environment variables set by the Parameterized Trigger plugin, then use the groovy plugin to lookup the displayName for the build (assuming the display name is different using Build Name Setter Plugin).

The display name in my case will be the git hash/revision that was built in the previous step.

import hudson.model.*
  def previous_build_number = build.getEnvironment(listener).get("TRIGGERED_BUILD_NUMBER_Build_byGitHash")
  def previous_git_hash = jenkins.model.Jenkins.instance.getItem("Build-byGitHash").getBuildByNumber(previous_build_number.toInteger()).displayName

def pa = new ParametersAction([
  new StringParameterValue("PREVIOUS_GIT_HASH", previous_git_hash)

// add variable to current job



Shaded Jar with Maven

          <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
              <Main-Class>Fully Qualified main class here</Main-Class>
          <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
          <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">


Insert SVN Revision Number into MANIFEST.MF



jConsole with Java 1.5

Start java application with the following arguments

Run jconsole from the command line pointing the to PID of the java process

jconsole <PID>

for example
jconsole 1234


jMeter – Regular Expression Extractor – Submit Form with Token

Create a load test that submits a web form containing a unique token to prevent multiple form submissions.

jMeter 2.6
Use jMeter Regular Expression Extractor ( Found in Right Click Menu >> Add >> Post Processors >> Regular Expression Extractor)

How To:
On http request 1 there will be a hidden input field that contains the token to be submited.
On http request 2 we will need to place this token value.

On http request 1, add a regular expression extractor with the following values.

Reference Name:TOKEN
Regular Expression:name=”TOKEN” value=”(.+?)”>
Match No:1
Default Value: NOT FOUND

On http request 2 insert the token value into the paremeters section with the variable ${TOKEN}


Added Simple Enemy AI and Zombies


Adventures into Game Development

So I have been playing around with game development for a while. First I had alot of trouble picking a game engine and a language. For a while, I was doing alot of webdesign with PHP and mySQL, which isn’t very similar to game development. Now I am currently working as a J2EE developer ( JAVA and JSPs). I first started out playing around with Unity Game Engine which is very nice, but I’m the type of person that likes to know how everything works. Unity does a great job at allowing you to focus on the game and its content rather then the engine and architecture of how the game works. I then decided that I would use jMonkey Engine and create a 3d space shooter type game. This was going well, but I felt I was spending more time tweaking physics settings and 3D modeling then actually coding the game.

Recently I decided I would give Slick2d ( http://slick.cokeandcode.com/ ) a try.

I am currently working on multiple aspects of this game, but the initial development was on creating levels. Slick2D supports levels created out of tiles that you can easily create with third party tools, but this only allows for very rigid levels. I decided that I wanted something more flexible. I finally decided that I wanted to be able to import a png image with transparent background. Anything opaque would be mapped as solid for the collision system. Below is the initial result.



Errors in the Wild

SEPTA having some Issues

Not really an error, but Black Super Man made his way onto the background of a college classroom


Auto Menu

Simple PHP scripts to create site wide menus without having to use a Content Management system or a database.
Very simple to use, no knowledge of php required. Greate for small static sites.