A Month of Plush Animals

Group Shot

Sometime around July I stumbled across something that got me interested in the idea of making my own plush animals (also called stuffed animals, softies, and plushies). So I started doing research and finding patterns on Etsy and by the middle of August I had bought a sewing machine and started making things. Above is my (finished) output after month.

Pea Pod - Open

 Peas in a Pod

I hadn’t used a sewing machine in about 20 years but after a few test pieces to get used to moving the fabric I dove in with the Peas in a Pod pattern from Tie Dye Diva which had fantastic instructions. The long straight sections and gentle curves were easy to sew and proved to be good practice. The zipper was an interesting challenge, but the instructions were easy enough. I only made one mistake while sewing it, which is how I found out my sewing machine auto-stops when it detects a jam (very handy, probably saved the needle). I decided to go a little overboard and embroider some solid color areas for two of the mouths, which I’ve never done before. In the end I actually like the pea on the left the best even though he’s the simplest.

Blue Whale

Stuffed Whale

Next up was the Stuffed Whale from DIYFluffies. I didn’t check the size before I started making it so it ended up being bigger than I expected (and using up the last of my polyester stuffing) but it’s very cute. This contained much smaller curves and tighter intersections than the peas so it was a good ramp up in challenge. Not every seem joined exactly where it was supposed to, but it worked out great.

Uramaki Roll

 

California Uramaki Roll

While this little California Uramaki Roll from ShoriAmeshiko was one of the first patterns I found, I waited a bit to start on it. While the basic shape is very easy the pattern (also well written) requires appliqué and I wanted to get some sewing under my belt first with the other patterns. Getting a good looking satin stitch was a bit of a challenge, especially on the thin black lines, but it came out well. Assembling was made easier by using a 1/4″ piecing foot I bought.

Green Luma

 

Luma

I’ve wanted to make some kind of Luma for quite a while, but I always figured I’d end up crocheting or knitting one. As it turns out sewing stuffed animals is way faster, so I’m glad I ended up making this one. At some point I found the Luma Plush Tutorial from ClearKid and decided to try something new. While the basic shape is easy, I made an embroidery file (PES file) to embroider the eyes. My original plan was to embroider both eyes at once but it turned out they needed to me just a little too far apart for my machine.

I was pretty annoyed with the process, the software I used wasn’t very good and required a Windows VM but at least it had a demo version I could use so I didn’t have to spend all the money to buy it yet. I think I’ve learned my lesson: given my art skills I stick to pre-made files or pay someone to digitize them for me.

I’d like to make more of these guys in all the other colors of fleece I have but we’ll see if I have the time.

The Elephant

The last item in the picture at the start of this post is a little elephant. The pattern is extremely sparse, and I ended up assembling the base incorrectly. It wasn’t until after I was looking at the finished object I was able to figure out just what I did wrong. While the head is cute the body (which is supposed to be sitting) looks more like a pyramid with a triangular base.

I bought some fabric called Minky that’s amazingly soft, but it’s a real pain to work with. Every time you cut it the edges shed like crazy. I ended up using a lint roller on it every time I cut it but I still got little fuzz bits all over. Because the fabric is so slippery I also bought a walking foot for my sewing machine, and it’s my new favorite. It makes it so much easier to get fabric through the machine that I’ve been using it more than anything else.

I don’t know if I’ll try this again. I think I’d have to remake the pattern to fix the issues I have and customize the base more to my liking.

Up Next

My latest project is quite a bit bigger, it requires quilting lots of colored squares together (which I’ve got done), cutting them up (also done), then sewing everything together to make something really cute (just started). The walking foot has made it very easy, but some bits are too small to reasonably do on the sewing machine and so I’ve been getting some hand sewing practice. It also requires two narrow fabric tubes which turned into quite an ordeal. I also got the itch to try making a video game quilt by piecing bits together to copy a sprite. We’ll see if that happens.

The Lumberjacks are Winning

I’m still working on ForestryService. I spent two hours last night trying to convert it to using a mutable vector instead of a list to keep track of the forest, but I couldn’t get all the monad stuff sorted out.

Tonight I switched to a non-mutable vector and had it running in about 10 minutes. When I turned optimization on the program flew until it got to image generation, which is still an issue. So with that solved I decided to try to track down my lumberjack bug.

It didn’t take too long. I added printouts to see how many lumberjacks there were at the start and end of each turn and quickly found the culprit. When a bear and a lumberjack collided and a mauling occurred I had the test backwards. I was removing the non-mauled lumberjacks and keeping the one who was supposed to be removed due to injury. One character change.

But that led to another issue, one which I thought might be a problem. We can end up with a couple of bears, but the number of lumberjacks quickly explodes. Within 25 years I have 1400 lumberjacks. At that size the list operations on lumberjacks (specifically finding if a square if free of other lumberjacks) absolutely dwarfs all other calculations in the program. I need to store them (and while I’m at it the bears) in sets. That would change my search from linear to log and should fix the issue. It will also make some of the tests cleaner since I don’t have to find intersections manually.

After that it’s back to the image code. I’m not sure if the problem is my pixel generation or the image library it’s self. I think it may be the integer division I’m doing to implement a basic scaling algorithm, but I haven’t profiled it since I switched to vectors.

Also I fixed all the spelling errors in the file. I can’t spell “forest.” I fixed it in the file and repo name before I first pushed ‘em to github, but I didn’t touch all the variables and methods before.

A Week of Haskell. Also… Ruby

Over the last week and a half I’ve spent quite a bit of time writing Haskell programs. I needed ideas for what to do so I started giving some of the challenges in /r/dailyprogrammer a try.

First Challenge – Lines

The first one was LineIntersections.hs, which I posted as a GitHub Gist. It was for the #163 – Hard challenge. This was mostly practice since it didn’t require much in the way of new skills compared to my WordLadders program. It took me a few tries to find a good line intersection algorithm that would tell me where the lines intersected and to get that implemented.

Second Challenge – Termites

Things got much more complex with #163 – Intermediate, my solution is called BunkerMaster. You’re given a little map and you have to help humans build walls around their living area to keep out giant killer termites that come out of a nest.

Most people were doing an A* algorithm repeatedly to keep closing off the paths that the termites could taken. This often minimized the number of walls used but also tended to minimize the human’s area due to the way people implemented it. I’ve written A* algorithms before, in a way that’s what WordLadders used. I wanted to try something different so after a while I came up with the idea of flood-filling the map from both endpoints and putting walls wherever things met.

To do this I marked two boolean bits on each square of the map to note if the humans or termites has reached that square. As soon as both bits were set we knew we reached a place that needed a wall. I would end up with more walls than necessary but the humans and termites has similar amounts of territory on ‘fair’ maps.

The biggest problem I had once my solution was done was that because I was processing both opponents each turn if they met in the middle you can end up with double walls. It could be fixed but it didn’t seem worth it.

Third Challenge – Befunge

I really had to press myself for the third challenge. #164 – Hard was a challenge to create a Befunge 93 interpreter. If you’ve never heard of it before it’s an esoteric language designed to be nearly impossible to compile by using a 2D grid of mutable characters as instructions and non-stack storage. Here’s an example that prints 99 Bottles of Beer:

v v0\1:\1:{CODE}{CODE}\!:p15-<     Bottles of Beer for Befunge
0 \ {befunge} >" ekaT">v   written by Brian Raiter, 5/97
0>>.0"llaw eht no "v<#,:   breadbox@muppetlabs.com
"\,     >"eno"^>0 #"^1^_v
c1,>51g#^_"ti"^. >vr :  $
"::^" down, pass "<e    5
>^|\*25,<^     # i e ^g1< 
  ,>052*":dnuor t"vbv:<
v0_^    .      , ^< " "
>52*".ll"v   >,^   fb e
v<v<v_$!|>"aw eht no r"v
""" ,:  >" ;"^      f ^<@
meo >^"bottle"<    "o   $
o m^"re:"<v  _^#g15<  v_^
s""  >52*^>"s"^v"les"<,:
"^<  ^"99 bott"<    >^>^<
>" yub ,erots eht ot oG"^

Yeah.

So if writing an interpreter (which I’ve never done) for an odd language (which I didn’t know) wasn’t enough, I pushed myself by using the State monad (actually StateT stacked on IO) to keep track of and modify the interpreter state.

My interpreter is called BefungeIt and ran the test programs I found. It’s not 100% compatible since I don’t limit the size of the stack and I don’t think Befunge is supposed to have 32 bit stack values.

Figuring out the state stuff took quite a few tries. My worst bug took me maybe 20% of the total programming time to fix. When I was supposed to pop two values off the stack and then save the result in a memory cell I was accidentally *restoring* the stack values at the end of the function because of the way I modified the state. This caused any program that used the ‘p’ instruction to go haywire, but after stepping through things (and learning a fair amount of Befunge along the way) I figured it out. In the end the state monad was quite useful.

Fourth Challenge – Forestry

Now I’m working on ForestryService, which I started for #165 – Hard which asked for an ecology simulator.

I started this using the StateT stuff from my interpreter to carry the state of the world. I’m learning quite a bit here as I’m using things like sequence, mapM_, and more.

I went crazy with this too, because what fun is a step-by-step ecology simulator if it doesn’t output graphics? So I’m doing something I’ve never done in any programing language: output an animated gif of the world changing over time.

In fact that’s the slowest part of the program by far. Having to get the state of each of the 10k cells each frame is where most of the time (and memory) are being spent in my program. At the moment I’m doing the easy thing and using lists of lists to store everything and that’s not nearly performant enough. I plant to try replacing that stuff with a mutable Vector, but I haven’t gotten to that yet.

I’ve had to fix quite a few bugs. Things are supposed to be able to move to any of the 8 neighboring cells, but a mistake in my list comprehension meant they would only walk diagonally. That was harder to find that it should have been because I forgot to call the functions that reset how far characters could walk each turn so they would only walk once ever.

Right now I know of one bug (besides performance): something is causing a plague to kill my Lumberjacks. I haven’t figured out what’s happening but over the course of a year I can lose hundreds of ‘em when no more than 1 should disappear. This is probably a test somewhere that’s not restoring values correctly, but it needs to be debugged.

When I’m done with this (or at least further through it) I think I’m going to ask /r/haskell about it. All the state transformation code looks way too imperative to me. I know that’s supposed to be a benefit of the state monad but I’m worried that I may have taken it too far.

I ran a quick profile on the code to see what was slow (any other hotspots are currently dwarfed by the gif creation, which was pretty obvious just from running it), but I was surprised how much faster the code got when compiled with -O2. Since I spent so much time in Java I’m not used to thinking about having to turn on a special optimization mode, that’s done automatically by the JRE. It’s been a while since I worked with a compiled language (well the Objective-C stuff I did didn’t need that kind of performance tuning).

Then There’s Ruby

Playing with Haskell has had quite an effect on my brain. I enjoy strongly type languages and have been LOVING ghc’s ability to find errors and suggest solutions. I’ve found myself doing things in Java at work and thinking “Haskell would have caught that”.

Well in the last few days I’ve been working on a little Ruby program/set of scripts at work and… it’s different. After my little Haskell immersion week going to an ultra-loosely typed language like Ruby is a huge swing of the pendulum. Besides simple parameter checking Ruby doesn’t seem to be too sharp at parsing. As an example I was missing an “end” in my file and instead of indicating the problem at the end of the file or in the actual problem area it indicated a problem with a requires statement at the top of the file (which was a total red-herring).

I’ve looked at Ruby before but I’m not very familiar with it and I keep getting surprised at how many options there are to do some things. Often there are multiple methods that are just aliases for each other (such as Array.length, Array.size, and Array.count), which makes me wonder a bit. I’m also having problems with documentation I’m finding online. While the core documentation is pretty good 3rd party gems often have highly questionable documentation that was clearly auto-generated and doesn’t provide any information that’s not in the method signature. I already know that a method takes 2 parameters and returns an Object; I want to know if that’s a String or a MyStruct or a whatever.

Bits of Ruby style are also getting to me. I’m so used to camelCase that I keep having to catch myself to match the use_of_underscores that seems to be the common Ruby style. I’m not sure about some other stylistic points, such as when I should use parenthesis in method calls or if people put “then”s on their “if”s.

I was quite happy to see characters on the end of method names to indicate if they’e a predicate (such as .nil?) or if they have side effects (such as .map!). I was really impressed with that pattern when I first saw it in Lisp/Scheme and it’s nice to see another language use it.

I’m having problems finding advice on Ruby online though. For example I wanted to print a number in Hex and did a quick Google search. Numerous sources told me that num.to_s(16) would do it, but Ruby complained that to_s didn’t take parameters. I’m not sure if that’s a version issue (I’m using 2.0, but 1.9.x and 2.1.x both seem to say they support it) or what. I’ve also run into a few things questions the solutions are clearly poor and a library found in a later answer is a much better solution. I ran into this finding people suggesting rolling your own command line option parser instead of something in the standard library. I get the feeling this is because of the number of people writing Ruby without much programming experience not knowing how many libraries are out there, much like I remember seeing in PHP.

Despite all this I’m having fun. I love playing around in new languages and I’m getting work done.

But I want to get back to playing with Haskell. I want to help my Lumberjacks.

WordLadders in Haskell

Over the weekend I wrote my first Haskell program. It’s called WordLadders and I’ve spent a total of about 5.5 hours on it.

I’ve been interested in functional programing for quite a while. Last year I started reading about Haskell more heavily, including all of Learn You a Haskell and Real World Haskell. I’d been trying to find a small program that I thought I could actually make on my first try, but I hadn’t come up with any really good answers.

Then on Friday Nathan Smith posted I wrote a Go program for solving “doublets” (AKA word ladders) using A* search algorithm on /r/golang. It uses a dictionary and the A* algorithm to try to connect two words through a list of real words, changing only one letter at a time. So if you entered “goat” and “toad”, the path might be goat -> goad -> toad.

Well that seemed simple enough to me. There are only four parts to the program:

  1. Reading in the dictionary file
  2. Creating a graph that links the words together
  3. Finding the shortest path between two words with A*
  4. Handling user IO (getting words, showing answers)

That’s the order I ended up writing the program in. Haskell has a reputation that “If the code compiles, it works (almost all the time)“, and that was my experience. My program contained only a single bug that the compiler didn’t find. When doing recursion within my A* implementation I was forgetting to remove the node I just processed from the open set, leading to an infinite loop. There’s no way for the compiler to catch that, but it caught everything else.

The actual process of writing the program was a little rough. I use IntelliJ all day at work and wanted to continue to use it, but the Haskell plugin doesn’t work right now. Development just picked back up after a two year hiatus and the old plugin doesn’t work with my (much newer) version of IntellJ. In the end I ended up using TextWrangler with a simple syntax highlighter and the ghci REPL.

My program works correctly as far as I can tell. It can find the longest word ladder (between ‘charge’ and ‘comedo’) in 8.5s on my 2010 MacBook Pro. It also correctly handles words that can’t be linked (such as ‘apples’ and ‘spoons’).

I’ve posted it to /r/haskell to get some advice on improving my program. There are a few things that I felt I stumbled on. There were also some issues I didn’t fully understand, but as often happens the solutions came to me while I was writing out the questions. Rubber duck debugging strikes again.

I’ll Try to Post in 2014

Usually I try to post when I finish a project. Unfortunately, in 2013 many of my projects went unfinished because I got distracted. Does that I did finish I forgot to post about. I’ll try and do better. Maybe.

I’ve made two tiny changes to the site. On the right-hand side, I added links to my profiles on other sites. Since I almost never got real comments, I turned commenting off again. This probably has to do with my post frequency, but it’s not a big loss.

Have you noticed that almost every sentence I’ve written so far as a comma in it? My speech patterns may be too predictable.

have been working on projects. I crocheted a couple of new creatures, 3D printed some new figures (which I haven’t finished painting), did some knitting, and started learning Crosstitch. As usual there are some pictures on Flickr.

Another project I was working on is a clock made from an Arduino and two OLED screens. The clock runs, but I haven’t made a menu interface for it yet. After that it still needs to go into a box of some kind. The code I have so far is up on GitHub, along with the Chronodot library I wrote.

Finally, after enough years I finally gave up and joined Twitter. You can find me at @foobarsoft.

I Made a Fez!

Inky's Finished FezLadies and gentleman, the first piece of crochet I designed myself!

No, above that. The fez.

Ever since I made my first Pac-Man ghost, I wanted to complete the full set. Last week (or so) I finished Inky, but decided that he would look better if I made him a little hat. I got about half way through it, decided it would make an awesome fez. I wrote the pattern down as I went:

Worked in rows, not a spiral.

First, the top of the hat:
SC 6 into magic ring               (6 stitches total)
INC in each SC                     (12 stitches total)
repeat (SC, INC) for one row       (18 stitches total)
Finish off with invisible finish

Sides of the fez:

I did this by SCing around each post in the last row of the
top, making a 90 degree turn. I did 4 rows of SC (again, rows
not spiral). After I made it, I wondered if HDCs or DCs would
have looked better.

Chain:

To top things off, I made a simple chain. CH 14 worked out
perfectly for me. I attached the last chain stitch I made to
the top of the hat. To give the fez's chain a little fuzz, I
cut the other end of the yarn from my slipknot short and
frayed it a bit. I tied another short piece of yarn around
that first CH and frayed it too.

If you haven’t seen it, you can find the invisible finish on Planet June. When I showed Inky to a few people, they all liked it; but they really spoke up when they saw his cute little fez.

Giving Up on Linear Bearings

I’ve officially given up on linear bearings. Two weeks ago I installed the linear bearings in my MakerBot, but didn’t like the initial noise results. Today I finished removing them and putting the old copper bushings back.

The linear bearings were amazingly smooth. If you put on one a rod and started tilting it, it would roll off the rod very quickly. There was almost no friction. In contrast, the copper bushings hold on for at least 5 to 10 degrees more before they start to move, and they have enough drag that they don’t pick up nearly as much speed.

But the noise drove me nuts. When I asked about noise solutions on the MakerBot google group they gave me some ideas, but I just couldn’t solve it. I got some white lithium grease, but putting that in the bearings made almost no difference (works nice on the bushings though). Everyone recommended PTFE based grease but I couldn’t find it locally and didn’t care enough to order it and wait.

If I owned a house where I could put the Thing-o-Matic a few rooms away, I would probably leave the linear bearings in. But in my one room apartment, I have to live right next to the noise and it was far too loud.

As long as my bot is open, I’ve been doing a few other upgrades. I installed M_G’s tensioning pieces, which worked great. When I reassembled my X axis is was pretty cool to be able to turn one bolt and have the slack in the belt pulled up. It’s so much easier than loosening four bolts, pulling the motor, and trying to hold that while tightening things back up.

I added Campbell’s Y-axis idler and I plan to install Joakim’s X follower. I made both when I first got my printer, but things weren’t calibrated well enough at that point so neither fit (nor worked) very well. Now that I know what I’m doing I know I can do much better. The Y idler should help with the tension (and hopefully reduce noise), while the X follower should make the X axis much smoother since it cuts the number of bushings in half. I also saw a reference to epideth’s Z axis bearings which I’d also like to. I don’t like how close the bushings on the Z axis are, the make it possible for the whole thing to wobble because it can’t support it’s own weight very well. Once the weight of the giant MK6 motor was gone, I was amazed how far the end of the Z platform could bounce if I pushed it with my finger. Having those long supports should help.

Last I finally got around to installing static drain lines which I’ve been meaning to do for over a year. When the air gets dry this time of year I start to get zapped by everything in my apartment, so I get really worried that I’m going to damage my MakerBot. I also used up a ton of 1/4″ kapton tape (mine came from MakerBot) to tie up some of the loose wires in the base, which really cleaned things up. I don’t know why I didn’t think of it before.  I cut pieces just a few inches long and wrapped them around the groups of wires every few inches.

After that I’d just like to get back to printing little things and painting them. That was quite a but of fun but I haven’t been able to try it in a long time. After all my tinkering it’s clear I’m pushing the Thing-o-Matic a bit, I’m wondering when I should give up and decide to buy a new printer. I’m not sure which model I’d want though. Make’s 3D printer guide was a fun read, but didn’t give me a clear winner.

Ultimakers have always looked nice, and I like that they’ve moved to cartridge heaters, but the lack of a heated bed means printing ABS parts would have to be small. I also really like Sailfish and have no experience with the Marlin firmware.

The Replicator 2 looks nice, and I’ve had great experiences with Makerbot. But I’m not sure about Makerware and would be happy to get away from Skeinforge. I hear so many great things about Slic3r, I think I’d be happy to move to it. While the Replicator 2 is much closer to an appliance (which is a good thing at this point), it doesn’t do ABS (the Replicator 2X will). The biggest con is that those printers are very expensive.

All of this is rather academic, as I’m not that interested in spending the money right now. But I keep thinking about it.

Let The Upgrades Commence (and a Brain Slug)

Upgrade Parts

Around November 6th I received my new extruder. I really wish I had ordered earlier as I ended up having to wait quite a while since I was so far back in line. It’s amazing how much smaller the thing is than my old MK6.

I’ve had some adventures with it. I didn’t like the gear it came with, it required way too much tension for my taste. I switched it to a Makerbot MK7 gear and the extruder is doing a great job. The extruder block and metal adjustment screw that QU-BD uses for tension work very well. All the parts shown in this post were printed with it. By the way, when installing something new, don’t forget the mods you’ve already done. I accidentally screwed through the lighting I had installed while putting the new extruder in. Oops.

I wanted to use a bearing based extruder drive again, so as one of my final prints I made Jag’s extruder drive (see No Bots Left Working). It was very easy to install, but I ended up with the oddest problem. In the middle of a larger print (the X carriage shown above) the printer jammed. When I opened up the extruder I found that it was clogged with plastic shavings. It seems that the bearing was positioned slightly below the drive gear, causing the filament to push against the side of the feed tube.

So I switched back to QU-BD’s parts and was able to print no problem. I’ve made whosawhatsis’s Minimalistic MK7 Replacement and ran some plastic through it, but I haven’t used it for a real print yet. I’m a little worried about the amount of tension that the spring holds, but it did work great for the quick test I gave it.

But the bigger deal is now that my printer is running again, I can finally do a bunch of upgrades I’ve had planned. I bought a bunch of LMB6UU linear bearings which form the core of the upgrades I performed. My hope was that this would allow me to speed my bot up and quiet it down a bit.

First I replaced the bearings on the Z axis using dnewman’s spacers. I have pictures of that process and the rest of my mods in my Flickr stream, which I should make a post on later. Next I put a pair of linear bearings on the Y axis with Jag’s Y Axis Bearing Holder/Spacer. To finish the bearing replacements I printed out MakeALot’s Linear Bearing X Axis Carriage for ToM and installed it. Like some of the others in the comments on the Thingiverse page, the parts that are designed to hold the bearings in place snapped on me, but I was planning on using the zip ties anyway.

With those mods installed, it is much easier to push the axis around, but things are not quieter. For some reason the Y axis seems to make even more noise than it used to, but the vibration goes away if I put just a bit of weight on the right side (such as resting a finger on it). I haven’t had a chance to look into that yet, but I’m hoping I can fix it. My apartment isn’t very big so I can’t put the printer a couple of rooms away where the noise won’t bother me; I also worry about the noise annoying my neighbors.

As long as I had everything apart, I decided to install famulus’s HBP Quick Leveler Redux. My old solution basically worked the same way, except there were no finger nuts so things had to be adjusted with needle nose pliers, which was very difficult. The new levelers were very easy to adjust, but I’m not sure they’ll stay installed. On the Thingiverse page people only seem to add levelers to the four corners, but I’m crazy and added them to all 8 outer points. That alone is odd because I added 2 additional bolts to make it easier to level the bed completely. Well I had to remove the two thumbwheels off the right side of the bed since they interfered with the X limit switch. The thumbwheels on the front corners mean that the bot can’t access the entire build surface; when trying to use the back corners the thumbwheels on the front can hit the sides of the front panel. Leveling my bed before was a big process, but it only had to be done once or twice (tip: thread-lock means the adjustments won’t shake loose).

It’s nice to be up and running again. The MK7/8 style extruder is very nice, and heats up even faster than my old MK6+. In fact, it makes it much more obvious just how slow the HBP is to heat up. I want to try whosawhatsis’s tensioner for a while, and I need to get things perfectly calibrated (I did a quick adjust on the great profile created by Makerblock’s Profile Maker). Then comes the real fun of upgrading to Sailfish and SF50 and seeing just how fast my printer can go. Plus, I have a roll of PLA I’m itching to try out. I really want to get back to printing out little objects so I can paint them and just add new toys to my desk.

To close this post, I’ll put up a picture of my latest Crochet creation. One day in late October I decided to make a second mini-Brain Slug, and it only took me about an hour and a half. Now we’s sitting on my desk, keeping Blinky in line.

Mini Brain Slug

Drawstring Whale Bag

Better Whale Bag Shot

A few weeks ago I finished the largest crochet project I’ve ever done, the Drawstring Whale Bag. Mine looks a little different because mine was made with DCs instead of HDCs by mistake. I found the pattern when it was posted to Reddit. Besides getting a ton of practice in DCs, this was also the first time I did FPTCs and also the first time I changed yarn colors mid-piece (for the eyes).

I’m not sure what I’ll do next. I’ve been thinking of doing another PacMan ghost, slowly working my way towards a set of four. The first piece of Crochet I ever did was a Brainslug, and later I made one of the mini-brainslugs for a friend. I loved the way the mini-brainslug turned out, and kinda wish I still had him. I might make another mini-slug so I can have my one (possibly to put on my PacMan ghost that I already made).

Rhythm Thief Wasn’t Finished

Ever since I first played the Parappa the Rapper demo on a Playstation Underground disc, I’ve loved rhythm games. When I saw shots of Rhythm Thief & The Emperor’s Treasure last year, I couldn’t help but look forward to it.

Well I finally got my hands on the game, and it has some very obvious flaws.

The game certainly has some good points. The music is quite nice, and some of the games really are quite fun. The game’s animated sequences are pretty amazing. After watching them, I’m starting to think that 3D animated movies (non-CG) might work pretty well Unfortunately the game has quite a few problems, some of which I’m surprised let stay into the release.

Let’s start with the core of the game: the music mini-games. The controls are quite inconsistent. Some of the mini-games use buttons, which work exactly as you’d expect. In some games (such as one in which you kick a soccer ball) using the touchscreen can really detract from the experience since it’s no where near as precise as buttons. There is just no good mechanical feedback on the touchscreen to know how close you are to touching and registering a tap. There is one dance mini-game where the controls work well, but they don’t do anything buttons couldn’t do just as well. This doesn’t have to be the case. Both Theatrhythm and Elite Beat Agents have show how well a touch screen can work for a rhythm game.

Still worse the controls are inconsistent. In some mini-games tapping the screen at the wrong time counts as a miss. In every game, missing are penalized very strongly. It’s trivial to go from getting an A to a D in the game. It’s like 1 step forward 10 steps back.

But in other mini-games, there is no penalty at all to using the screen at the wrong time. That means in some (such as cooking) just holding the pen on the screen and sliding it back and forth will get you an easy A. It has nothing to do with the scene in the game; but since it’s only checking that your pen is down and/or moving at the right moments it’s an easy win. This takes all the challenge out of some games.

Of course there are the requisite motion controls, which are amazingly slow, insensitive, and wildly break immersion. I know the 3DS can do much better, it’s pathetic.

While I enjoy the anime style visuals, the game has some graphical problems as well. There is a level where you are running across a rooftop to escape perusers, but you can’t enjoy the scene at all. Between the fast movement, low resolution, repeating texture, and occasional object flying into the screen it’s hard to get any detail out of the scenery.

The outlines are the characters are generally too this, and just shimmer. The cooking mini-game suffers from this terribly. In a static scene, there shouldn’t be any problems. But the white chef robes combined with ultra-thin lines for detail on the uniforms means they look out-of-focus. I tried turning off the 3D effect to see if that made things any better, but it didn’t make a difference. It’s very distracting.

Earlier I said that the animated scenes are beautiful, and they really are. Of course, they are videos, which means they are pre-rendered and the depth can not be adjusted. So when animating these scenes, they naturally chose to maximize the depth. If you don’t find having the 3D slider on all the way comfortable, too bad.

3D is poorly handled in general. During minor dialogue in the middle of some games, a static 2D drawing of a character will show on the top screen. This drawing is at zero-depth (screen plane), making it easy to see in front of the rest of the action. On the other hand, the end-of-level screen is designed to look like it’s popping out of the screen. Between the small letters and the fact they are near the edges of the screen, this makes the information very difficult to focus on, breaking any immersion.

But the dialog can keep you from getting immersed anyway. The game takes place in France, and takes every opportunity to make hit you over the head with generic French stuff. The main character’s dog is named Fondue. The people you talk to one the street drop little bits of French that would be in a 1st grader’s travel guide. I found this disingenuous, but the real problem is that it’s occasionally spelled wrong. “‘Toot suite”? Really?  It’s tout, and there isn’t supposed to be an apostrophe in front of it.

The voice acting is generally acceptable, but it’s not good. That’s just as well since the subtitles don’t always match the readings. The character will say “Baby.”, but the text will say “Childish.” That’s the entire sentence in that instance, and it was wrong.

If this takes place during battle, it’s often spoken by those 2D character drawings I mentioned. They (roughly) lip-sync with the dialog, except for the few times they’re off by about 1/2 second. The animation matches the dialog well, and that’s the expensive part. But a quick scene where a character talks by cycling between mouth-open and mouth-closed frames? It can be way off.

I am actually enjoying the game. When walking the streets it’s largely identical to a Layton game, and I’m eagerly awaiting the first 3DS entry. Rhythm Thief shows it could work really well. But I keep running into baffling little decisions that massively detract from the game. Just a few little bits of polish could have made such a big difference. As it is the game feels mediocre as a whole, but it could have easily been quite good.