This page contains written feedback on your Creature/Monster projects, provided by the following reviewers (listed alphabetically): Kate Compton (Northwestern), Johannes DeYoung (CMU School of Art / IDeATe), and Golan Levin (CMU School of Art).
Note: Assignments were presented to the reviewers ‘anonymously’, using your course nicknames. Links to assignments were provided to the reviewers on Wednesday 2/23 at 10pm; assignments received after this time will still receive course credit, but will necessarily receive attenuated feedback.
- A creature of two moods, gracefully and respectfully swooping to the target, or fearfully backing away. “Facing” the target makes it clear where its attention is. Could use a little more rotational momentum, the quick turns make it feel weightless and artificial.
- The work’s ability to clearly convey two contrasting emotional states (curiosity and fear) is compelling, and is especially so given the very minimal graphic language. The use of lerpColor() is effective. There’s an opportunity to introduce more nuance, or apparent nuance: could there be variation in how long it takes for the creature to become curious again? There are missed opportunities for richer interaction: a very basic one is that you don’t make use of the mouse click; but you also you don’t measure how long the user is fretting the creature. I would recommend hiding the cursor with the noCursor() command. Your code could use some comments — not for others, but as a gift to your future self, so that you can look back and understand how you made this.
- Humor is elegantly implied through this seemingly simple interaction. Reminiscent of Heider and Simmel’s Study in Apparent Behavior (1944), I thoroughly enjoy witnessing the trepidation of a biggish square facing a tiny circle.
- Great use of physics. The heaviness of the critters combines with their attentive eyetracking to create a delightful feeling of helplessness. They’re very aware of my mouse but they emphatically can’t move. The variation of the critter’s shapes is also a moment of delight and adds a playful rhythm to the interaction. A lot of personality emerging from simple rules.
- A charming experiment, and a good first immersion with Matter.js. The eyes looking at the cursor idea is initially compelling but quickly becomes predictable; this could be spiced up by having the creatures occasionally look at each other, and/or also by temporally punctuating their gaze with occasional blinking. It’s unclear to me how the creatures interact with each other: they appear to bump into each other slightly, but not so much that they mutually repel each other and stack over other; instead, they just overlap. I wish the background/environment was more intriguingly designed: why is the creatures’ playground shaped the way it is? I’m aware that OpenProcessing offers some scaffolding here, but I think it’s still advisable to put a message that says ‘press a key to start’ on the screen, which goes away after the first keypress.
- Satisfying creation and mouse interaction makes for appealingly animate creatures. Interactions between creatures feel a bit lackluster by comparison, revealing territory for further exploration.
- Softly glowing jellyfish. I like the variety of follower particles and their varying amount of attachment to the main head, as well as the gentle motion of the background. The body particles do feel a bit stiff, but you are walking a line between having them feel too stiffly attached to the head, and making them so loose they no longer feel connected.
- The visual design is attractive, with a self-evidently adept control of color, depth and form, and the springy trails give some much-needed unpredictability to the creature’s kinetics. But the project’s interaction design (or if you prefer: the puppeteering interface) is markedly less interesting, and so the project does not sustain interest well. The decision-making that underlies which properties are autonomous and which properties are assigned to the user’s control, and why — seems shallow or hastily considered. For example: not only is the creature’s position linked to the cursor, but also its tilt/orientation. This could have been put under the creature’s own expressive control, with a new relationship established with the user’s actions; this a missed opportunity. Also, did you actually observe any jellyfish (e.g. on YouTube)? They pulsate, and the rate and depth of their pulsation could be additional expressive (or reactive) dimensions of your design; something like this would have been easy to implement.
- Appealingly designed. The interaction of light from the jellyfish onto atmosphere particles expresses nuance and depth. The springy tendril interaction is simple but satisfying.
- Great texture here. The nodules of the blob give it so much more visual interest and tactility. I also appreciate that the image istself stays very simple, allowing you to focus on the size shifting and the play between the negative space and the bulging creature. The “bounce” on size change also adds a lot of materiality (jello, not clay) to the scene.
- The soft bodies are nicely implemented, but in both their visual design and in their kinetic behavior seem generic and lacking in character. They also behave less like ‘living creatures’ (with internal motivations), and more passive objects, like water balloons. Adding an autonomously moving element inside each creature’s guts would provide a motor of activity and, hence, interest. Some individual variation (in their size, color, decoration — or even better, their simulated physical properties) would have been an appealing thing to add as well, and would have extended the joy of interacting with the project. It was thoughtful to add instructional text on the screen; however, the typography itself is utterly unconsidered, and the story told in this text (“click to create a new blob”) misses a major opportunity to frame the work. It also would have been appropriate to hide this text once the user had clicked or pressed a key; leaving it on the screen is a befuddling decision. The WordPress documentation is nice, but lacks a link to the interactive project.
- Loads of emotive potential in the interaction of blobs. Fear-factor is an interesting design prompt, but transforming scale is only a start. The rate of change from one state to another (timing and spacing) could better express underlying psychology.
- Wonderfully appealing spiderlike movement. Has a great blend of smooth body movement and stickily frenzied “foot” placement. Reminds me of the monster’s movement in Carrion (the game). Having the row of 3 creatures also gives you more interest and a fuller rhythm as the foot positions update at different times.
- The locomotion is attractive and sensitively executed. The behavior of the overall project when the cursor gets very close to an individual creature shows the limits of your design; in this case, the rotational behavior is poorly behaved (both mathematically and visually), and it seems illogical that the ‘lead’ character responds when I’m hovering over a secondary character. (Perhaps switch the identity of the leader?) It might be an interesting experiment to add a drop-shadow (using CanvasRenderingContext2D.shadowBlur) so that the creatures are more distinguishable when they overlap. The colors of the project are uninspiring and represent a missed opportunity.
- I’m a believer! The snappy interactions, the variable tempo changes, the subtle animation offsets, and the overlapping actions of creature parts add-up to an appealing gestalt. I’m spending way too much time with this one — nice job!
- The concept is cute, but the being itself is robotic and unreactive. The jaw works at a steady rate, and the creature glides wieghtlessly like an ice skater, but this feels like the wrong movement for a small grungy puppy. It needs more sense of “interior life”: more distractions, a sense of attention (or inattention) or an intentional (or unpredictable) rhythm.
- An actual game; a solid start. The text advises us not to let the dog eat poop, but there appear to be no consequences to letting it do so — a missed opportunity. (It could keel over, turn green, etc. — like a Tamagotchi, this would involve the player emotionally in the dog’s well-being in critically important ways.) I appreciate that the instructional text hides after the first interaction. The graphics, while full of quirky charm and laudable character, are nonetheless more small, cramped and illegible than necessary. Rather than having the dog always follow the cursor, you could have it move autonomously (choosing to go to unpredictable locations), straining against a springy leash held by the cursor, etc.
- Finally, a computational experience rooted in natural order. This scatological stroll starts amusingly enough, but disappoints in its absence of consequence. Why shouldn’t the dog eat it? And what about ankle biting?
- Good use of squash and stretch here, and the tail accents the motion. Overall though, the tail and the body don’t feel like they “go” together. The mechanical bouncing suggests a straight-laced, regimented character (not a bad character, per se, but not one that is supported by the other motion present here). Feels more like 3 tech demos, rather than a whole character.
- You are animating the creature’s tail implicitly (with simulated springs) but you are animating the squash-and-stretch of the creature’s body explicitly (in your bounceDisplay() function). It is very difficult to integrate these two different approaches in software, and visually, they appear to contradict each other. Consider using physics to produce the squash-and-stretch of the body instead.
- I’m sad for this one. No amount of effort at interaction can save it from its off-screen demise.
- Really lovely work with soft pixels fleetingly rendering a ghostly drawn portrait. The user interaction feels heavy and out of place. The brush is huge and solid against the diaphenous pixels. Whare am I feeling about this? My role feels uncertain. The image itself is unclear as a character….it feels like this is a story about the colony of pixels describing a face they can’t see.
- I’m familiar with the codebase you used (derived from Alex Mordvintsev’s Neural Cellular Automata), and I appreciate your straightforward presentation of your process in using it. From a technical perspective, I’m assuredly impressed that you were able to figure out how to train the model and get Mordvintsev’s code working. I also appreciate that getting others’ code working can be very educational, and I also appreciate that you were curious about conducting an experiment to use this code to make a creature. That said, it feels like there isn’t much of ‘you’ in here, other than the image you used to train the CA. It also seems unfair that you’re hosting this on your own server, as opposed to working within the same constraints (p5.js in OpenProcessing) as the rest of the class.
- The mutability and regeneration of form is compelling. The work is most interesting when the original grid parameters are disrupted — when regenerating faces overlap and the boundaries expand beyond something predictably organized.
- A cheerfully anxious community of caltrops. The number and variety of critters here makes this piece really special: there’s always something to draw your eye: a new size, and sudden movement, a catastrophic tumble. Individual agents are less important here than overall impression of a chaotic family of acrobats.
- I love the joyous way these things bounce. Their ultra-minimal design is a strength and shows care rather than haste. The dense overlapping of the creatures makes the scene jumbled and difficult to read, however, and diminishes the legibility of the creatures’ quirky charms. The project could be more legible if it were organized in “2½D“, with the rear layers of creatures shifting up the screen. I would recommend ‘individuating’ the creatures by giving them slightly-randomized values for their damping and spring constants.
- The inconsistency of interaction actually gives these creatures some charm and personality. The occasionally toppled tripod and panicked jumping are satisfying starts, but leave me wondering what more could be implied through clustering and scattering. The experience is well worth both minutes it takes to figure out what’s happening.
- Soft colors and a charming lurch. This creature lumbers to catch up with the mouse, but its bounciness makes us root for its optimism. I like that it “faces” us and turns by shifting its top units.
- I’d like to know more about this charming creature’s world. Even a tiny handful of features in the environment (gumdrop trees, etc.) would go a long way to making this more interesting (even better if they somehow affected the creature’s movement). I appreciate the use of springs on the ‘ears’; the design suggests that each ear really ought to have its own spring, with its own rest length, damping, mass, and spring constant — it would look great for the ears to bounce independently. The lumbering walk (and the sheared perspective) gives this a lot of character, out of proportion to the project’s minimal means. Good color.
- This waddling rabbit-thing exhibits curiously satisfying scale shifts and overlapping actions when the mouse changes direction. The speed… is… slow… and the forced perspective could go further.
- A soft and subtle flower tunneler. I don’t often think of pixels with “softness” but there’s a velvety darkness to this, and a good sense of place. That said, it feels like a place, it doesn’t feel like an “agent” or even a life-form. The cells only act on my interaction, and don’t have momentum of change when I leave, or movement of their own.
- It’s more of a paint program, though, isn’t it? The interpolated diagonal and lateral movement is appealing; the grayscale response curve could use some nonlinear adjustment (it seems like it’s always either too dark or too bright). I would love to see more autonomous growth by this mold, informed, perhaps, by cellular automata. For the high end of this kind of investigation, check out the work of Sage Jenson (including this live software).
- This mold makes a mesmerizing paint application. After its initial application, there’s little sign of life. Perhaps there’s potential for secondary action in its growth, distribution, scale, or pulse.
- The softness and blurred jitters give me an impression of old film stock, like this. There is a clear sense of overwhelm and attack (loving but threatening) here. With too much excitement, though, the movement is muddy and unreadable. Try capping your velocity to prevent the runaway shooters, if you want to clarify it.
- A standard flocking algorithm, albeit rendered with an appealing transparency and well-chosen pixel transfer mode. (If the flocking code is wholly your own, I’m impressed at how compactly written it is. If it’s not, please indicate your inspirations or sources.) The colors are strong; the fluttering of the creatures’ wings is a very appealing detail. The project looks good and has an unquestionably satisfying responsiveness, though not using the mousePressed() function seems to miss an opportunity for a deeper interaction. My main concern with the project is just that some significant effort is required to make a flocking algorithm like this behave in a way that is not generic-looking.
- The snappy interactions are satisfying and the consumptive relationship of fire-pests to sun-thing is evocative, for sure. Let the consequences of that relationship play out to an end — total consumption resulting from stagnation.