Engineers thrive on problem-solving, often inventing challenges where none readily exist. This spirit is perfectly embodied in the E-Learning Heroes community, a hub for innovation and creativity in the e-learning world. Recently, the E-Learning Heroes Challenge posed the question: How Would You Build a Connect Four E-Learning Game? While many in the E-Learning Heroes sphere embraced this challenge, it initially left me somewhat uninspired. The remarkable example by Russell Killips within the E-Learning Heroes forum, leveraging motion paths and states to faithfully recreate the classic game, seemed a tough act to follow. Perhaps my lukewarm reception stemmed from less-than-fond memories of Connect Four, reminiscent of rainy childhood holidays filled with incomplete board games. Battleships, on the other hand, always held a greater appeal.
However, one aspect notably absent from Russell Killips’ impressive Connect Four creation for E-Learning Heroes was the ability to play against a computer opponent. This gap was quickly addressed by Devlin Peck, another prominent figure in the E-Learning Heroes community, who shared a brilliant example featuring a JavaScript-powered AI. This digital adversary, surprisingly astute, could swiftly defeat an unwary player.
Inspired by these E-Learning Heroes contributions, I decided to tackle the challenge by creating my own “CPU” opponent, one that would dynamically react to the player’s moves. Regular readers might recall my previous foray into JavaScript for the crossword challenge within the E-Learning Heroes community. However, for this Connect Four inspired project, I aimed for a solution built purely within Articulate Storyline, minimizing reliance on coding languages I’m still mastering.
I’ve long championed the use of hidden objects in Storyline to orchestrate on-screen actions. Imagine a stagehand backstage, manipulating levers to control the performance – that’s often how my e-learning designs, especially for E-Learning Heroes challenges, operate. This concept sparked an idea, drawing inspiration from the whimsical inventions of cartoonist William Heath Robinson and the era of early computers – colossal machines filling entire rooms, relying on intricate dials and cogs for computation.
The Bombe, an electro-mechanical marvel of early computing, immediately came to mind. Conceived by Alan Turing at Bletchley Park in 1939 and brought to life through the engineering prowess of Harold Keen from the British Tabulating Machine Company, the Bombe was a codebreaking machine of incredible complexity. It employed an array of rotors and wire brushes to process countless equations simultaneously, deciphering encrypted German military communications. In our age of pocket-sized computers, it’s hard to grasp the sheer scale and physical presence of these early machines. Remarkably, one such codebreaking machine was even nicknamed “Heath Robinson” due to its intricate and seemingly convoluted design!
This historical context fueled my thought process: Could I replicate a “mechanical computer” within Storyline to power my CPU opponent for this E-Learning Heroes challenge?
Spoiler alert: The answer is yes!
Pinball Logic: Building a Random Sequence Generator
My inspiration further solidified when I encountered Turing Tumble, a company I’d been following on Twitter. They produce a fascinating game where players construct mechanical computers powered by marbles to solve logic puzzles. This toy is a direct descendant, albeit several generations removed, of Turing’s Bombe. While it won’t crack Enigma codes, it performs a surprising range of calculations using only gravity, ball bearings, and levers. This tangible representation of computation resonated deeply with my vision for a Storyline-based mechanical computer for the E-Learning Heroes challenge.
With this direction, I decided to take creative license with the E-Learning Heroes Connect Four challenge. I shifted from the “four in a row” concept to a simplified version of Battleships, a game I christened FOURPEDO!
For FOURPEDO!, my CPU opponent needed to target different grid locations on each turn and, crucially, adapt its strategy upon scoring a hit. While Storyline’s random number feature offered a starting point, relying solely on it could lead to the CPU repeatedly targeting the same grid squares, resulting in an inefficient and easily defeated opponent. My CPU required a memory of its previous actions.
My initial experiments focused on building a Turing Tumble-inspired random sequence generator within Storyline. The video below demonstrates the successful outcome of these early tests:
[No video embed available, text description will suffice]
Video Description: A demonstration of a Storyline-based random number generator. A visual element (a box) moves across a line. Each time it crosses, a random number is generated, targeting a corresponding grid section. Importantly, if a number has been selected previously, the box resets, forcing Storyline to select a new, unique number.
This video illustrates the core mechanism: each time the box crosses the line, a random number is generated, and a corresponding grid area is targeted. However, observe that if a number has already been picked, the box jumps back to its starting position, compelling Storyline to choose a different number. But how is this achieved? The diagram below provides a visual explanation.
Expanding this concept to a 6×6 grid for FOURPEDO!, my mechanical computer initially selects a random number between 1 and 36. Once a hit is registered, the random number range narrows to the area occupied by the player’s submarine. This strategic shift means that once the CPU finds your submarine, it becomes a race against time to locate and sink theirs first! This added layer of complexity makes the game more engaging and challenging, showcasing the potential of Storyline for creating sophisticated game mechanics within the E-Learning Heroes context.
The creators at Turing Tumble seemed impressed with this digital adaptation of mechanical computing principles for e-learning, a testament to the versatility of Storyline and the ingenuity of the E-Learning Heroes community.
Play FOURPEDO!
Broader Applications Beyond E-Learning Heroes Challenges
Randomization is a crucial element in effective e-learning design. Most leading authoring tools, including Storyline, offer features like shuffled answer choices to prevent learners from memorizing question order during repeated course access. This basic randomization enhances learning and assessment integrity.
However, more complex applications of randomization often demand advanced techniques, frequently involving JavaScript. While JavaScript offers powerful solutions, building a “mechanical computer” within Storyline presents a viable alternative, especially for developers less comfortable with coding. This approach provides a visual and intuitive way to implement sophisticated randomization logic without deep coding knowledge, opening up creative possibilities within platforms like E-Learning Heroes and beyond.
Here’s a simple example utilizing a streamlined version of my random sequence generator. In this quiz example, the mechanism ensures learners never encounter the same clue twice within a single game session, nor do they receive clues in the same order if they retake the quiz. This enhances the replayability and learning effectiveness of the quiz.
To explore this example and understand its inner workings, download a copy here.
Final Thoughts: Tinkering and Innovation in E-Learning
FOURPEDO!, born from an E-Learning Heroes challenge, was undeniably a passion project. With 36 tiles, each with four state changes, requiring 144 individual triggers, it’s a complex creation. Is it a “whimsically elaborate” design, reminiscent of a Heath Robinson contraption, or an “implausible contrivance”? The beauty is in the eye of the beholder!
However, the underlying principle of building a “mechanical computer” within Storyline holds significant potential. It offers a sound approach for specific scenarios where visual, trigger-based logic provides an advantage. A similar mechanism powers the background logic in my entry for E-Learning Heroes Challenge #237, preventing players from falling off the map by moving too far horizontally. This demonstrates the adaptability and reusability of this technique within different E-Learning Heroes challenges and e-learning projects.
A JavaScript solution for these randomization challenges almost certainly exists – JavaScript often provides elegant and efficient solutions in e-learning development. If you’re aware of such solutions, please share them in the comments! The E-Learning Heroes community thrives on shared knowledge and collaborative problem-solving.
In the meantime, keep tinkering and experimenting. You never know where your explorations, especially within the stimulating environment of E-Learning Heroes, might lead you. Embrace the challenge, explore the possibilities, and continue pushing the boundaries of e-learning innovation.
