In early January 2009, I embarked on developing a game featuring UFOs within Second Life. Now, with the advancements in technology and a renewed interest, I’m endeavoring to port the game to mobile devices and web browsers, leveraging a variety of APIs in the process.

7 Seas Fishing

Back then, there was a popular game sweeping the grid known as 7 Seas Fishing. Players could visit any location where the game was set up, purchase a fishing rod along with a bait bucket, and commence fishing. The game rewarded players with experience points, enabling them to level up. Anglers were also treated to a wide array of randomly acquired fish, each with varying rarity classifications. Additionally, the game offered blueprints for constructing various items. Players could even adorn themselves with some of the fish or showcase them in an aquarium. The game also hosted contests, and community members had the ability to introduce customized elements to the fishing experience. To draw a comparison, one might liken it to Pokémon due to its diverse collection of creatures.

While I appreciated the concept, fishing wasn’t particularly my cup of tea. I’ve dabbled in fishing mini-games on platforms like Ultima Online, Everquest, and World of Warcraft, finding them enjoyable initially but eventually feeling like a time sink. For me, the real enjoyment lies in the challenge of crafting software.

Sculpted Prims

In the Second Life environment, structures were constructed using basic shapes like cubes, spheres, cylinders, and tarsus. These shapes were customizable, allowing users to modify, cut, skew, hollow out, rotate, resize, texture, and link them together to create intricate objects. Often referred to as Sculpties (or Sculpty), the sculpted prim served as a precursor to mesh objects that were introduced a few years afterwards. Introduced in 2007, this feature enabled two-dimensional images to have their RGB values translated into vectors and converted into meshes. It was an innovative method of leveraging the existing architecture to accommodate mesh objects.

Drawing from my previous experience with 3D modeling tools, this was my moment to shine. However, crafting a sculpted prim required some serious effort. My comfort zone lay in exporting to the basic “obj” format, which was compatible with nearly every 3D modeling software, or exporting to alternative file formats.

Sculpties weren’t standard in the 3D modeling communities; they felt more like a hack. Nonetheless, they represented a significant improvement over previous methods of modeling within Second Life. NURBS modeling was unfamiliar, felt daunting to me and posed a high barrier to entry. My understanding was that NURBS modeling generated curved edges between points based on the subsequent point in the path. In essence, the edges of models might never intersect with any of the NURBS points; rather, they served as conceptual guides for the model’s shape, with a more intricate mesh generated from them. One of the key advantages of NURBS was the ability to create less complex mesh objects for distant rendering, known as LOD (Length of Distance) rendering.

Converters and plugins were being developed by individuals to support the format, but they often had bugs. I remember grappling with various tools that made achieving straight edges challenging, especially at corners, without sacrificing a few vectors in the same location to eliminate curvature.

Among the 3D modeling software I used at the time were:

• 3D Studio Max
• TrueSpace
• Blender
• ZBrush
• Wings 3D
• AC3D

Additionally, community-created software like Rokuro and Tokoroten emerged for crafting Sculpt Maps. I primarily utilized these tools to generate simple shapes. Rokuro enabled me to draw an edge from the top to the bottom of an object, then rotate it around the center to generate the image for a sculpted prim. On the other hand, Tokoroten functioned as an extruder, allowing me to outline an object and extrude it. This brought me back to my days at the Art Institute of Pittsburgh where I learned how to loft shapes onto paths.

AvPainter & ArtRage

The community developed some impressive tools, one of which was AvPainter. This tool enabled me to import a sculptie and effortlessly paint various layers by clicking and dragging my mouse over the 3D model. I devised an image with a grid overlay, facilitating a visual understanding of how the points were arranged. The creator was receptive to feedback and incorporated several feature requests I had, such as the ability to read sculpted prim images generated from Rokuro and Tokoroten, not just OBJ files.

During that period, I had a compact Wacom graphics tablet that allowed me to utilize a wireless stylus instead of a mouse for drawing. The tablet could detect the pressure I applied with the stylus. Teaming up with ArtRage software, I had a blast crafting fresh and vibrant textures to design new UFOs effortlessly.

Working Concept

By January 11, 2009, I had a functional prototype of my UFO game in motion. Players would purchase a flashlight and scour the surroundings for aliens using it. As they searched, their energy would gradually deplete, prompting them to acquire additional energy. The game incorporated elements such as evidence left behind by the aliens, cover-ups, and various other intriguing elements.

There were further ideas to ensure that each “site” offered a unique experience, encouraging increased alien activity and better discoveries. Additionally, I was exploring ways to add depth to the gameplay, making it more challenging than simply waving a flashlight.

My last progress involved integrating it with a web-based backend for data storage. However, by October, the concept had evolved into a scavenger hunt system while I was developing an inventory service.

UFO Revitalization

Fifteen years later, while I was on vacation, a friend approached me about developing an app that would utilize GPS and speech.

The GPS aspect triggered memories of the UFO alien game I had crafted many years prior. During a drive back to South Carolina with another friend, I discussed some ideas I had for the UFO app. There are numerous GPS-based applications tailored for road trips, tours, and scavenger hunts. I reminisced about my enjoyable experiences with geocaching before phones had GPS capabilities. Niantic, known for popular GPS games like Ingress, Pokémon GO, and Harry Potter Wizards Unite, had their fair share of issues.

Common problems included:

• Battery drain from features like video camera, motion sensing, GPS, complex 3D models, and augmented reality
• Inability to modify gathering areas like Pokestops, Gyms, Portals, Fortresses, Greenhouses, and Inns
• Reduced enjoyment without a group

Personally, I desired something distinct:

• Leaving a mark on the world
• Creating custom items for others to collect
• Enjoyment when alone, at home, or in rural areas
• Simple creation of virtual or tangible scavenger hunts, perhaps using QR codes
• Moving objects between locations
• Including a guest book for leaving messages
• Incorporating scriptable objects akin to LSL in Second Life

Geolocation Api

I began exploring the current state of web APIs that night, focusing on location detection. I devised a simple and expedient method to determine my current whereabouts. As I journeyed back home the following day, I periodically consulted the web page to track my location.

GitHub: CodeJamboree/html5-gps

While on the journey back home, I pondered the intriguing notion of using the game to search for Alien Life and contemplated how it could function. Visiting numerous unfamiliar locations sparked the idea of discovering unique items that weren’t available in my usual haunts. For instance, perhaps a visitor center could offer a distinctive item to collect, akin to the novelty tokens created by squishing pennies as souvenirs of one’s travels.

3D Models on the Web

Once I grasped the simplicity of capturing GPS coordinates, I tackled what I deemed the most challenging aspect: integrating 3D graphics into a web page. My history with this endeavor stretched back to 1998, dabbling with VRML, which never gained widespread adoption. I also ventured into Direct3D and WebGL on various occasions, often encountering limitations imposed by operating systems or web browser capabilities. Fortunately, with the maturation of technology, 3D graphics now adhere to standards and boast several libraries.

I delved into experimenting with the Three.js library to display 3D models on a web page. The most formidable hurdle was transitioning my old models from images to a file format natively supported by the Three.js library—Graphics Library Transition Format (glb/gltf). After scouring through numerous defunct plugins and installing various 3D modeling programs, I eventually deciphered the process of converting them to a more standardized format. Although I typically steered clear of third-party viewers to connect to Second Life, I discovered that I could use the Phoenix Firestorm Viewer to download a sculptured prim image as a COLLADA file using the old pie menu dialog. Subsequently, I imported it into Blender and exported it as glTF.

After loading the model, I delved into applying textures but encountered difficulty in programmatically rotating the texture by 90 degrees. Despite attempting various approaches to address the issue, including setting texture.rotation = Math.PI / 2, the texture failed to rotate as intended. Given that this was a proof of concept, I resorted to using an image editor to manually rotate it.

Additionally, I acquired the skill of cloning the model. I implemented a ray caster to track mouse interactions with objects from the cameras point of view, enhancing the user experience by adding a glowing outline to highlight the hovered-over object and displaying the texture on a canvas element in the corner. Subsequently, I devised a method to detect UV coordinates on the object when clicked, enabling me to mark a dot on the texture.

To further enrich the user’s interaction with the 3D models, I introduced the ability to directly paint on them by dragging the mouse from one model to another. I augmented the user experience by displaying the current texture being edited in a separate area of the screen, facilitating drawing on either the 3D model or the texture image itself.

Finally, to add the finishing touches, I integrated a simple color picker with gradient options on a canvas element, providing users with the ability to adjust the line width as desired. With the capability to paint objects in 3D, I had achieved a basic working version reminiscent of AvPainter.

Sound

Following the Facebook post featuring my miniature UFOs, my father noted the absence of accompanying sound. I’ve faced hurdles in creating original sound effects for web applications. In the days of BASIC programming, such as QBASIC/Quick BASIC, one could craft various sounds using the computer’s speaker. However, with the emergence of visual integrated development environments (IDEs) on Windows 3, native audio support seemed to dwindle, largely due to the prevalence of sound cards like SoundBlaster, Adlib, and the scarcely supported Disney Sound Source. While I often turned to tools like sfxr for generating sound effects on the fly, they lacked the personalized touch I sought. The fond memories of Game Maker’s capability to draw waveforms for crafting 8-bit sounds resurfaced, motivating me to pursue a similar solution.

In the early 2000s, I maintained a website abundant with images and sounds. During this period, I delved into various file formats and meticulously embedded information into their headers. Essentially, I treated each file as a miniature database. I developed website code capable of parsing these headers to display pertinent information before presenting a download link for the file. I took additional steps to showcase details such as the duration of audio files, dimensions of image files, and the contents of compressed files, including all filenames. Among the formats handled were MIDI, WAV, MP3, JPG, PNG, GIF, ZIP, and BMP. Regrettably, I couldn’t decipher the intricacies of wave files at the time, as I also aimed to visualize audio waveforms.

In May 2019, I embarked on a journey to decode the waveform within a RIFF file containing PCM data (*.wav). After persistent efforts, I finally achieved success in reading and visualizing the data.

GitHub: lewismoten/riff-wave-reader

It was about time to explore the latest offerings of web APIs. Before long, I stumbled upon the Web Audio API. Swiftly, I set up a web page to generate an oscillator featuring sine, square, sawtooth, and triangle waveforms. Additionally, I crafted an audio buffer filled with noise. Employing an audio analyzer, I captured the waveform and rendered it onto a canvas element.

Inspired by the Game Maker sound editor in the 80’s, I devised a method to draw a waveform using a mouse and load it as a periodic wave. As I grew accustomed to crafting sounds, I proceeded to construct an 88-key piano on canvas, meticulously mapping frequencies to each key.

GitHub: CodeJamboree / audio-fx

Through this short experiment, I gained valuable insights into audio manipulation. The oscillators brought to mind my experiences with signal generators in electronics. Additionally, I utilize Teenage Engineering’s OP-1 as a digital audio workstation (DAW) for music production. Its array of synthesizer and drum engines resemble oscillators, each with distinct effects applied. I’m curious whether I can replicate various sound effects using oscillators by applying different audio effects. To explore this, I began experimenting with Tremolo as a gain effect.

Unfortunately, I couldn’t replicate the appearance of the periodic wave when graphing the data from the audio analyzer. I suspect that either the periodic wave or the audio buffer is the key to generating 8-bit sounds. The periodic wave offers the advantage of adjusting its frequency when different piano notes are clicked, whereas the audio buffer plays exactly what it’s programmed with.

To progress, I may need to analyze the sounds generated by GameMaker to gain a better understanding of the frequencies and waveforms. I could examine the VOC files or simply use Audacity to record the audio and proceed from there. Alternatively, I could explore SFXR, although it offers more options and effects. Starting with a simple approach and then expanding seems like the best course of action.