Christopher O'Brien

First four-leaf for me in 2011

2011-03-11T11:17:00.001-08:00

Mobile Photo Stream

2010-10-09T18:05:00.001-07:00

Bug paintings

2010-10-08T17:29:00.001-07:00

Sitting outside with tea from a sock, thinking about what I want to paint.

I know I want this to be a dragonfly, but my previous attempts have all been too busy. I think my goal with this will be to subdue and focus attention to only a few colorful areas, rather than having the entire thing be bright. I have seen plenty of paintings use a dark to ochre blend to bring light to the center, and I think that is what I should attempt to emulate this time.

For the dragonfly, I can find a happy medium between reality and colorful impression, hopefully.

I am torn between wanting to add some sort of backdrop elements, such as dead leaves. On the one hand, if I pull them off correctly it may help to make the whole focus thing more natural. On the other hand, serious danger of becoming too busy.

I think this will work.

I will save the ladybug and stag beetle for collaborating with Zoe. I may try to get the same underlying effect if the dragonfly works out, and Zoe can bring in the color like last time.

- Posted while roaming

Testing out Posterous.

2010-10-07T16:14:00.001-07:00

A Pair of Warcraft Addons

2010-09-30T17:09:00.001-07:00

I've been poking around with Lua a little bit lately, working with Addons for World of Warcraft.

TOTTler and tottler

Original TOTTler addon: http://wow.curseforge.com/addons/tottler

My tottler friendly fork/utter rewrite: http://code.google.com/p/obriencj/source/browse/tottler/trunk

To understand why an addon such as tottler exists, you must first understand the rogue ability Tricks of the Trade (also just tricks or tott). Tricks is an ability which a rogue can cast on a friendly target. When the rogue makes a special attack on a creature after casting tricks, the threat which is generated from that attack, and any threat generated for the next six seconds, is passed on to the friendly target. This allows a rogue to help a tank keep their threat high, and it can assist in AOE pulls of many monsters at once.

In addition to the threat transfer, tricks also gives a damage boost to the friendly target for the duration of the transfer.

As if that wasn't enough fun, the tier 10 two-piece bonus makes tricks also cost no energy, and instead gives energy back to the rogue. This makes the ability a massively important tool, as energy is commonly the limiting factor in what a rogue can do.

Tricks of the Trade works as three separate affects. When it is originally cast, the rogue gains a buff that lasts for 30 seconds. After the first special attack happens, that buff disappears, and another buff (which lasts for 6 seconds) appears. This second buff is the one that actively transfers threat to the tricks target.

At the time of the first special attack, third buff is placed upon the tricks target, and this buff grants them their damage boost.

It is possible to cancel the rogue's threat transfer buff. Doing so does not effect the target's damage boost buff.

In essence, this means it is possible to use tricks, get the energy refund from the 2pc t10, give the damage boost to a non-tank (such as another rogue), and NOT give the friendly target any additional threat.

There was a fair amount of consideration over this in the forums, and the original author of TOTTler wrote an addon that would automatically cancel the threat transfer.

What's most interesting is that the original TOTTler also was clever, and permitted the player from deciding ahead of time whether the tricks target should or should not get the threat. For instance, if the target was the tank, you'd definitely want the threat transfer. If the target was a mage, you really wouldn't want to give them even more threat (unless you were trying to get them killed, which is fine by me).

I picked up TOTTler, but I found that its command interface was terribly broken, so I took a look at the code and found a lot of bits of ugly (nothing declared local, unnecessarily using an XML file for the frame description, etc). I decided that I should make myself useful, and contribute some patches back to the original author.

The problem is that the original author isn't very responsive (to me at least). Also, the code for TOTTler wasn't kept in a source control system that I could find.

Luckily, TOTTler was licensed to be in the public domain! So I set about re-writing it as a friendly fork, calling it simply "tottler"

I cleaned up the handling of events and commands. I also added the ability to have the addon notify you when another rogue is giving you the damage-increasing buff.

There are three parts of tottler that I am particularly happy with, and will likely re-use in other addons that I write in the future.

First, and I have already re-used this, I have a very short pattern for creating local functions for subscribing to and handling events. I create a table with keys matching the event names, and values referencing the local function to be called. I then create an empty Frame, and set its On_Event handler to a short function which simply looks up the event in the table and executes it's function with all of the remaining arguments to the event.

The table-lookup can be significantly faster than a if/then/else block checking the string over and over again, and it's much more terse and easier to add new events to... you just put the event name and its handler in the event_handler table and it'll work! See lines 702 through 718.

Secondly came handling the command-line interface for the addon. The original TOTTler would throw an exception of you specified an incorrect number of arguments, or an unknown command. This was something that I really wanted to fix.

I set up a table listing each of the commands, the function that should handle the command, and some short help text. The dispatcher would then unpack all of the arguments into a list, find the correct command (and fail gracefully), and pass the arguments to the correct function.

Again, table lookup being faster than if/then/else, this also permitted me to very easily write a help command that would present all of the known commands and their arguments and descriptions. Adding a new command involves updating the table and writing a handler function. I will definitely be re-using this code in the future. See lines 471 through 566 for the main command handler and commands table.

Finally, I needed a reliable way to detect the application of multiple buffs. For this, I put together a handler for the UNIT_AURA event. Each time the UNIT_AURA event fires, the various buffs on the unit are collected into a table for caching. For each buff that was added to the cache, but which was not in the previous cache, a table is checked. This table is keyed by spell_ids, the value is a handler function to be called when that spell_id is found, but only the first time! So we if we have an aura on the player which wasn't found the last time UNIT_AURA was called, we know it is newly applied. We check if we are interested in this aura (by seeing if there's a function associated with that spell_id), and if so, we'll call the handler function. At the end of the event, the new cache is stored, and the previous cache is destroyed. See lines 594 through 647.

Unfortunately come patch 4.0.1, it will no longer be possible for an addon to cancel a unit's buffs automatically while in combat. This will kill the primary purpose of this addon. It's entirely possible that addons like this are the very reason for the change.

Whose Aura Is This?

http://code.google.com/p/obriencj/source/browse/whoseaura/trunk

One of the things that often annoyed me when looking at my buffs and debuffs is that I could not easily tell who had applied what spell on whom. The information is obviously available to our game clients (if you watch the combat log, you'll see the name of the original buff casters when the affects are applied and when they fade), why isn't it in the user interface?

So I wrote the simple whoseaura addon, which simply binds to the GameTooltip and watches for the SetUnitAura call. Whenever this is triggered, whoseaura uses the UnitAura function to get detailed information such as the unit_id of the aura's caster.

Now, unfortunately, a unit_id is not always terribly useful. A unit_id will be something like, "player" or "target" or "party3" rather than an actual name. One must use the GetName function to convert a unit_id into an actual meaningful name, rather than a relationship.

Problematically, if there's no ready unit_id to describe the relationship between the caster and the player, UnitAura will return nil for that field! For example: a paladin you are not in party with casts Kings on you. If you target the paladin and mouse-over the Kings tooltip, you'll see their name as the caster. However, if you un-target them, the caster will now display as "Unknown" because UnitAura wasn't able to describe a relationship to that player!

A possible fix for this would be to instead monitor the combat log, which does not use a unit_id, but which instead will always provide the full name (and server) of the casting player or creature. However, this would require some caching and a lot of filtering.

For now, I am alright with whoseaura operating with the limitations of the UnitAura function, because it keeps the addon utterly tiny.

The Arduino as a Sequencer

2009-07-19T20:33:00.000-07:00

There are a number of simple projects that use the Arduino (or another ATmega168/328 platform) as a tone generator and/or sequencer. In a fit of activity one night, I realized that with a broken pair of headphones and some spare wire, I had everything I needed to make my Arduino into a fun noise generator as well.

Thus began work on the sequencer_1 code.

Sequencer_1

The first iteration of the sequencer software that I put together for my Arduino was pretty basic, re-using a lot of existing example code (such as the frequency-output function freqout). It was very simple, with all of the interesting stuff happening in the loop function:

check for the "record" button
check the status of the scale and note knobs
put any recorded note/scale combinations into the sequence at the current index
read the tempo knob
play the current note/scale for however long the tempo requires it to be played
set the speaker pin HIGH for a little while
then set the speaker pin LOW for a little while
advance the index of the sequence

It's a simple square wave emitter, taking very little code. It has a mildly annoying halt in-between steps of the sequence. This is because it has to stop the playback on the speaker pin in order to do everything else (advance the sequence, check the record button, etc). This halt manifested as audible noise, almost like a "pop." Even if you played the same tone for multiple steps in the sequence, it would be broken up by that artifact, rather than sounding like a single held note.

Sequencer_2

The second iteration of the sequencer software started to make use of the internal interrupt handlers. It attached Timer1 at a very high frequency and used it to flip the speaker pin between HIGH and LOW based on a dividing counter. The Timer2 interrupt was used at a lower frequency to service the tempo. The loop method was still used, but now it only performed the recording of the sequence. The input and output were nearly identical to the sequencer_1, except now there was no gap between the steps of the sequence-- a note could be held and would sound like a single solid tone.

Sequencer_3

Both of the previous sequencers had used a minimal number of parts, but had only been capable of outputting a square wave. I wanted to get into some analog action, so it was time to try and output a wave.

First I needed to figure out how to programmatically determine what voltage I should be attempting to produce at any given moment. I would commit an interrupt to updating the output voltage at a sampling frequency of around 10kHz. A second interrupt would act as the tempo handler. Whenever the tempo would update, it would set a global multiplier and divider pair. The divider becomes a counter which decrements each time the sampling interrupt fires. When it reaches zero, an output level is selected from a pre-defined table representing the sine wave. The index into this table is incremented by the multiplier each time the divider counter reaches zero. This has the net result of simulating a sampled wave at the appropriate frequency.

To actually convert the given calculated value into a voltage, a serial-to-parallel chip is fed the byte. When it latches, the eight-bit output is fed into a digital-to-analog converter. In my initial build, a simple R/2R ladder DAC worked out fine, but required a voltage divider on the output (to drop the signal to a normal 1.5V line-level range) as well as a passive low-pass filter to quiet down some component noise.

Code

The code so far is over at my Google Code page

Arduino Pinball Hacking

2009-05-22T12:19:00.000-07:00

My pinball machine does not have a functional MPU. The MPU is the board that has the logic for the rules of the particular game, and it communicates with the phyisical aspects of the pinball machine (the solenoids, the lights, and the switch matrix). Without a working MPU, the pinball machine doesn't do much of anything at all. Luckily for me, replacement MPUs exist for older machines like mine, and are relatively inexpensive.

I've been messing around with the Arduino lately. It's an excellent little embedded platform for hobbyists and goofing around, and you can do serious work with it as well.

I decided that it would be pretty spiffy if I were to create an MPU replacement using an Arduino. The interfaces to the other boards (lights, solenoids) and the switch matrix is documented with great detail in the manual for the machine itself. There are full schematics, as well as a number of repair tutorials available on the internet. There was even a project to create an ISA controller card doing just what I want my Arduino to do.

I envision my project progressing as such:

get a switch matrix scanning routine and associated hardware working. This will permit me to monitor the ball on the playfield from a PC connected to my Arduino via the USB cable.
get a lamp refreshing routine and associated hardware working. This will permit my controlling PC to set the state of the playfield lights
get a solenoid triggering routine/hardware working. This will permit my controlling PC to pop bumpers and play chimes, etc.
get a score display routine/hardware working. This gets me the ability to set the scores on the back-box, and is the last piece of direct interaction.
write a simple game rule set that runs on the PC that allows me to play the pinball machine
figure out how to make the Arduino autonomously follow that game rule set (either a library of the hard-coded game rules, or some sort of super-simple byte-code indicating events to watch for and what to do to the score and bumpers and lights, etc)

It's auspicious, but it seems like it could be many hours of fun!

This would permit me to take off-the-shelf Bally replacement parts and create my own pinball games!

Given the above features as a "version 1.0" of the project, I've already got some "2.0" plans in my head. For instance, the hardware for the controller could act as a man-in-the-middle for an authentic MPU. It could both monitor exactly what the real MPU is doing (and report it to the PC) and it could completely override the MPU. It could trick the MPU by showing fake switch presses.

The Mechanical Sudoku Turk

2009-05-19T09:39:00.001-07:00

I've come up with an excellent art/tech project just now. The basic concepts are to create a Mechanical Turk aimed at solving sudoku puzzles. A player would input the puzzle via a keypad and switches on the panel of the machine, and pull a lever. The turk would come alive and start banging and clacking and tooting and clunking as it "mechanically solved" the puzzle. The actual brains would be a simple program on an embedded platform hiding inside the console, obscured by the gearing and woodwork. Different solution steps would produce different mechanical events, set to a specific metre. If the puzzle could not be solved, then an error buzzer would fire, and it would go into "tilt" mode. Instructions on the face would indicate how to reset the tilt mode, and claim your fortune. A successful solve would play a short unique sequence of notes and emit the fortune card.

The Pinball Machine

2009-04-03T20:42:00.000-07:00

I've inherited a Bally's Evel Knievel pinball machine. It had spent the last decade buried under some miscellaneous junk in my father's garage, but it is now sitting in a partially disassembled state in my library.

Let me start out by saying that the back-glass is in beautiful condition.

Everything else looks pretty bad. The playfield is scratched and very dirty. The protective mylar shapes that had been applied over portions of the field are worn. The rubbers are cracked in places, and the plastics are yellowing and some are slightly deformed. The MPU is dead, so I haven't tested any other components yet.

I've got a replacement rubbers set, and have begun tear-down for a full clean and wax of the playfield, and a full bulb replacement while I'm there. While it has only been in the garage for a decade or so, it's been nearly twenty years since I recall it being in a playable state, and even then most of the bulbs were burnt out, so I figure I may as well do them all now while I'm knee-deep in things.

I will be very happy if I can get it to play again. Once that's achieved, I think I may attempt to sand and re-paint the sides. I've seen numerous places online offering stencil kits for this particular machine. The hardest part would be matching the colors!

I'm having a spectacular time figuring out how it all works. Every time I make another discovery, I am amazed at how well-thought-out the whole thing is.

Please forgive me if this post lacks coherency, it's currently 11:56pm, and my brain wanted to be asleep hours ago.

Pictures of Pinball Progress

Enhancements for IceHUD and Grid

2009-01-03T13:42:00.000-08:00

Here are a pair of add-ons for World of Warcraft that I've been using to tweak the behavior of IceHUD and Grid.

IceHUD_HungerForBlood allows rogues to follow the duration of their HfB buff, and has some coloration niceness to see how many stacks of it you have on you. This was originally the only HfB bar for IceHUD, but now it is actually a replacement for a buggier bar that is already included.

GridOnly is a tiny mod that attaches an extra layout option to Grid, "Hide default party frames." This is for people who want to use Grid and only Grid to view party and raid membership.

Both of these are hosted over on my Google Code project.

Talented Export Popup

2009-01-01T12:16:00.000-08:00

If you're using the excellent World of Warcraft talent addon Talented, you may have been frustrated with its exporting feature, which will only output the URL to your talent build to the most recent chat channel. The following (extremely long) macro will take the currently selected talent tree from Talented, and will put the export URL into a popup window, where you can actually copy it.

/script StaticPopupDialogs["Z"] = {text="URL:",button2=OKAY,timeout=0,hasEditBox=1,hasWideEditBox=1,OnShow=function() getglobal(this:GetName().."WideEditBox"):SetText(Talented:ExportWowheadTemplate(Talented.template)) end}; StaticPopup_Show("Z")

Java class file disassembler

2008-10-20T15:44:00.000-07:00

I began working on a disassembler for the Java class file format, and it's come along very rapidly. The only hold-up has been in unpacking the constants pool when there are Long or Double constants present, and that trouble was simply due to ambiguity in the specification about exactly what it meant that such constants took up two entries in the pool.

I've posted my work thus far in SVN, and have created a short project page for it.

PUG PSG

2008-10-11T23:55:00.000-07:00

I've put together a write-up of exactly what this PUG PSG addon was supposed to do. The idea itself, while originally intended for use inside of World of Warcraft, could probably be adapted to any number of distributed peer rating systems. I'm not sure exactly how often such a thing is necessary (I mean really, there's almost always *some* way to centralize a system), but hey the idea's out there.

http://sites.google.com/site/obriencj/projects/pug-psg

Snippets and Such

2008-10-10T14:22:00.000-07:00

I've started to import code snippets and such into my personal google code project. Nothing of real merit as yet, just junk I've been keeping around and some things that I worked on as a whim.

Some stuff I've imported so far

My little take on the Church of Lambda in Python
brine, a python module for pickling actual code
an async unpacking class in lisp. This was originally part of a much more grandiose idea that I will explain in a later post.
deli, a python module for working with del.icio.us (and performing more advanced queries upon tagged bookmarks therein)
PUGPSG, a World of Warcraft addon that would allow you to maintain a distributed peer rating system. Stands for Pick-up Group Personality Skill Gear.

Google Experiment

2008-10-06T21:08:00.000-07:00

I'm messing around with a bit of a Google experiment right now. At different times and places I have maintained a personal blog, a personal website, and various code repositories. I was astonished to realize that Google offers hosting for all of these things nowadays, and much more besides. I was curious to see just how many different Google services I could actually find common use for, so I hatched a simple idea to find out. I'm going to attempt to maintain an active identity using only those services provided by Google.

At its most basic, an online personality can be established with just a blog, such as this one hosted with Blogger. However, for the purposes of maintaining longer, less time-sensitive chunks of information, a simple website can be preferable. So I have also set up a personal website using Google Sites. Because some of my projects will involve either pictures or source code, I've created a personal project on Google Code, and have set up my own account with Picasa.

You can read more about the ideas for how I can use various Google-offered services on the Experiment page itself

Intro

2008-10-06T20:48:00.000-07:00

Hello, my name is Christopher O'Brien, though I often go under the moniker "siege," as it is much shorter to say. I've decided to begin maintaining a short blog regarding some simple aspects of my interests as they come to pass. I have a wife and a daughter, three cats, and a house.

My creative hobbies generally revolve around some act of creation. My projects cover a range of mediums, from software to electronics to mechanics to construction. I'm interested in clocks and pinball machines and small engines and LISP and the building of sheds and decks.

When I am feeling less creative or motivated, I will spend time playing World of Warcraft, where I am an Undead Rogue going by the name of Narlic.