Quite Unusual Newsletter #35

We're excited to share are latest newsletter as we finally reach the point of wrestling with the transition from foundational systems code to crafting actual games and finding out hoe theory doesn't life up to practice.

The last 4 weeks were a grab bag of accompleshment in programing

### Working on AIFAS:

• documented the internal working of AIFAS's vigncil system
• added named priorities with explicit relationship to .vigncil files
• updated the.vigncil file VScode extension
• redid the vigncil system so the Dialogue is a type of Portrayal instead of a type of Part

Number crates:

*now convert floats to fractions directly from the mantissa and exponent * impled .powi() for my fraction and fixpoint crates * redid .sqrt() and .pow() for my fraction crate use the method I learned impling .powi() * fixed some bugs in my fraction and fixpoint crates

Some misc math stuff:

• made a rational trig replacement for atan2
• made a function to add two quadrance together
• made a function that finds the square number factors of a number
• modified square number factors finder to only merge factors if the higher factor already exists

started on generic chess-type game engine:

• made function to calc scored for squares
• made function to generate possible moves

Some other achievements where:

• developed a base personalities types based on 4 motivation and 3 struggles
• made a project to help automate something in my personal life that was eating up all my time.

TeaserTuesday

Through the window's lens, Mentor Waxworth quietly observes the world, her innate curiosity ever present, seemingly unperturbed, as if everything is simply as it should be...

Alta Article

Internal routines have an integer priority that is used to determine when portrayal repeats. portrayals are sorted into buckets based on their priority then keep repeating the portrayals in the highest bucket.

my first implementation of the .vigncils file you specified the integer of the priority directly. but that means if you want to insert a priority in between two existing priority so have to go through and change all the higher/lower priorities to make room for the new one.

So to solve this instead of specifying an integer you specify an identifier for the priority and Directed Acyclic Graph of which priorities need to be before another.

You can't just use a topological sort because if the DAG doesn't restrain it to a specific ordering it will just make one up for you. so for example if you have:

A->B->C
A->D->C

you don't want to go ABDC or ADBC you want A(BD)C.

but what happens if you have

A->B->C
A->D->E->C

it can't say if B is equal to D or E So I implemented a breadth-first search starting at the nodes without any parents

but if you have something like:

A->B->C
D->C

if will put B and C at 2 then try to put C at 3 but it's already at 2, so it will fail.

So I did was to keep track of a separate chain for each node without a parent then when adding a node check if it has already been added to the other chains and if so shift the integers in the shorter chain so that the integer it wants to assign to the Node that already exists in the other chain is equal to the integer in that chain and then merge the two chains.

But then there are cases where a chain is moved back so far the it's end goes past the current so one can't just have a list of nodes that need to be added to the chain but also the depth they need to be added at.

Though I took a lot work to implement all that most of it was because I had kept adding tiny improvements and it got very crufty and I'm not a fast typist to actual enter the code took white some time. I probably spent an hour in total decide what I wanted the program to do but I spent 3 full days on it as implement my idea then realize some case where it wouldn't work. If I had known then I know now I would have rewritten it from scratch 2 or 3 times instead of just making the changes to it. but because it was so crufty it was hard to see all the changes that needed to be made.

I did rewrite it once when I painted myself into a corner with borrow checker. It was easy fix I just borrowed the stuff mutable from the start instead of borrowing immutable then reborrowing it as mutable

Quite Unusual Newsletter #34

In this edition of our newsletter, we're thrilled to share the latest developments in our game's art department. Our talented artist has been hard at work, and we've got some fantastic progress to showcase. Let's dive right in.

Switch had a Profuse Production of Progress with:

• Windows & Curtains Model🪟
• Room Model🏠
• Chair Model🪑
• Waxworth Robe👘
• Scene Setup🎥
• Scene Lighting💡

Alta Artistry

Alta Artistry has been put into a separate post. https://subscribestar.adult/posts/1242841

TeaserTuesday

With each step, Lium confronts the shadows of fear that linger. In the quiet corridors, courage becomes his guiding light, pushing him forward to face the unknown with unwavering resolve.

Quite Unusual Newsletter #33

In the past four weeks, Alta has been a whirlwind of productivity. From enhancing a sex card game to exploring old code intricacies to deciphering RPGMaker autotiles. Let's explore the highlights of Alta's recent ventures, each demonstrating both skill and ambition.

The 2 weeks after the last update Alta continue working on the sex card game then took a easy coding win

• Remade the icons for the pleasures of the sex game
• Finished designing the layout design of cards for the sex game
• Ported his path finding algorithm and test app to Rust

Revisiting his old code before I completely forget how it works

• Finished first pass at implementing Emergent Economies for Role-Playing Games
• Rewrote the markets for EEfRPG
• Finished the first pass at implementing the EEfRPG agents

Encouraged by the successes updating his past code Alta up with some other old projects

• Wrote a non parser for WorldGrower's constants
• Made a 16.16 fixpoint crate based on libfixmath
• Implement the fast atan algorithm I used in my fraction crate in my fixpoint crate

Started skunkworks project to try to impress some into joining our team

• Figured out how RPGmaker EX autotiles worked
• Figured out how RPGmaker MV does its autotiles
• Implemented RPGmaker MV autotiles in Rust
• Started on a program to render RPGmaker MV maps

In order to get his skunkworks project going he added some features to AIFAS

• Implemented numeric comparison operators for vigncils
• Implemented a feature so vigncils can print a value from the Blackboard
• Added the ability to use those new features in .vigncils files

TeaserTuesday

Continuing down the hall, Lium's strides echo a quiet resolve. The corridors may be long, but his determination is unwavering. Each step carries not only the weight of the present moment but also the hope for brighter tomorrows.

Two fortnights or productivity for Alta

In the past four weeks, Alta has been a whirlwind of productivity. From enhancing a sex card game to exploring old code intricacies to deciphering RPGMaker autotiles. Let's explore the highlights of Alta's recent ventures, each demonstrating both skill and ambition.

Resurrecting Code, Bridging Talents

Alta embarked on a journey through the realms of game development, and here we follow his exploration as it unfolds across two distinct yet intertwined narratives. In the first, we delve into the depths of code, resurrecting Rustlang's Emergent Economies for Role-Playing Games. Then, in the second narrative, we traverse the landscape of hope, as Alta endeavors to impress a fellow creator, seeking to unite talents and bridge the gap between programming prowess and creative vision in game development. Together, these articles illuminate the iterative nature of the creative process, showcasing the resilience and innovation that define the evolving world of game design.

Unraveling the Mysteries of old code - Rejuvenating my RPG economic sim

After the last newsletter, I decided to revisit my old code before I completely forget how it functions. Reflecting on what might be my initial attempt at a substantial program in Rustlang, which involved implementing Emergent Economies for Role-Playing Games.

Once I’ve got it operational, I plan to adapt it into a simulation of a Freeism economic system. Emergent Economies for Role-Playing Games is essentially the economic aspect of Jonathon Doran’s dissertation, “Procedural Generation of Content for Online Role-Playing Games,” which provides additional insights beyond the well-known article.

The algorithm proposed by Jonathon Doran and Ian Parberry doesn’t function as intended. It relies on information that isn’t available at certain points in the algorithm, specifically utilizing market share data while still determining trade outcomes.

Initially, understanding the code was a challenge, but upon re-reading the paper, I began to recall enough to comprehend my old code better. I never completed the original implementation, as I mentioned earlier, because one cannot simply implement their algorithm due to its reliance on unavailable data.

I believe I’ve finally determined what data to store, although I’m still deliberating on the appropriate data structures to utilize. I had to thoroughly review the code for the market, which handles the trading day’s progression, trade matching, and subsequent reporting to agents.

During this process, I ended up rewriting numerous chunks of code, which I believe has significantly enhanced clarity. Additionally, I opted to rename several variables, opting for descriptive sentences instead of the shorthand I typically resort to when coding hastily.

After I finally implemented everything and cleared up all the lints, I took a break. I never did get around to testing it to see if it works. I was having trouble getting to sleep on time as I got lost in my work.

From the past to the future - new possibilities appear on the horizon of the tomorrow

In the pursuit of relaxation after my struggles with e Economics sim I tried enveloping myself in some gaming. There's a certain allure to immersing oneself in a different universe, living out adventures and stories that transcend the boundaries of reality. One game, in particular, had been on my radar due to the considerable anticipation it had been garnering.

However, upon diving into this virtual world, I was met with a series of challenges. The game, unfortunately, was plagued with engine issues. Movement within the game often resulted in my character getting stuck, disrupting the flow of gameplay. Additionally, the overall responsiveness of the user interface (UI) left much to be desired, further dampening the gaming experience.

The game's narrative was intriguing, but I found myself missing dialogue due to the absence of clear indications. It left me in a state of uncertainty, unsure whether the game was taking a timed pause or awaiting a click to progress the story.

Despite these setbacks, Their game aligns perfectly with my long-held aspirations. It is still just a small demo, but the creativity and artistry behind it were evident. This led me to consider rewriting it with my AIFAS engine I have been developing. I hoped that by doing so, I can impress the author enough to potentially collaborate.

While the author's creative prowess shines in writing and game design, my strengths lie in programming and engine development. Our complementary skills could weave captivating experiences, bridging the gap between narrative intricacies and essential gameplay metrics.

Even if collaboration doesn’t materialize, the enhancements I’m making to AIFAS for a full-fledged game won’t be in vain. Regardless of the outcome, this journey of developing games and the potential for collaboration, reminding me of the power of perseverance, creativity, and teamwork in the face of challenges.

In the end, it's not just about creating a game, but also about the journey and the potential connections made along the way. Whether or not our paths converge, this experience has been a valuable lesson in the intersection of gaming, programming, and collaboration. And who knows? This could just be the beginning of an exciting new chapter in the realm of game development.

Quite Unusual Newsletter #32

We're thrilled to finally showcase Alta's remarkable progress with Blender in this issue (exclusive to SubscribeStar). As we celebrate Lium's 1st year in 3D existence, Switch has redone his model to mark the occasion—coincidence or fate?

Switch's achievements in the past 4 weeks include

• Protag UVs 🌐
• Protag Skin Textures 👨‍🦰
• Protag Final Rigging🦴
• Protag Clothes UVs 🌐
• Protag Clothes Textures👕
• Prologue Image Replacements 🌄

Alta Artistry

Alta Artistry has been put into a separate post. https://subscribestar.adult/posts/1202946

TeaserTuesday

Embracing the power of resilience, Lium strides down the hospital corridors with determination and hope. Each step carries a promise of support for the mentor whose light has left an indelible mark.

Quite Unusual Newsletter #31

Instead of having issues focusing on Alta or Switch we are alternating between art and programming. So the report on Alta's Blendering will be in the next issue, but if you check the SubscribeStar you'll find a full article on the development of the sex minigame.

Alta amaginated the following work the past 4 weeks

An idea for testing the integrity of a voxel structure popped into his head as he lay in bed and it was keeping him from sleeping so he:

-Impled it -Found out it worked for the example problem but not in the general case. -Coded up another idea after the first idea didn't work

Some other miscellaneous things Alta did:

-Made the basics of a Discord bot to handle voting -Developed so operating docs for the studio -Put the prologue image we have done into the Pharaoh Demo

On the bookkeeping side, Alta did the following:

-Used nom to create a parser for our bookkeeping files -Created a program to check for any mistakes in our bookkeeping -Created a function to write a transaction to the appropriate files -Created a Godot scene to display an account

A summary of Alta's work on the sex mini-game:

-Coded the basic trick-taking mechanic -Made an AI that plays random moves -Implemented keeping track of which cards have been played from the player's deck -Had the AI play itself and played around with how to generate the cards

Some other things Alta did were:

-Made a viewport that wraps things around to the opposite side -Moved all of my geometry code into one place -Made my fraction crate correctly handle Negative zero -Fix a bug in my fraction crate when adding a negative number and a positive number

TeaserTuesday

Amidst the echoes of memory, Lium navigates the corridors of change with hope and a heavy heart; a somber journey to visit the mentor who once illuminated his path.

Inital coding of the sex minigame

As I delve into the world of game development, I wanted to share the progress and lessons learned along the way. So I'm now doing a more detailed journal of my journy developing my games.

I just embarked on the exciting adventure of developing my sex card game and it has already been a rollercoaster of challenges and creative decisions.

The foundation of the game revolves around players taking turns playing cards that deal pleasure, each with specific thresholds for each type of pleasure. If the total pleasure dealt by a player's cards surpasses the threshold of an opponent's cards, they are 'eclipsed' and removed from the field. However, I encountered various challenges during the development process.

Graphic Design Dilemmas

To kick things off, I initiated a Godot 4 project and began creating the card's graphical representation. Struggling without icons for pleasure types, I considered using traditional playing card suits but there are 5 types of pleasure. I tried drawing inspiration from foreign card suits, but in the end I added a star to the French suits and assigned distinct colors to each type.

Crafting the Pleasure Mechanics

After successfully crafting the card's design, I delved into the game logic: Players take turns playing cards on the field. Each card provides a specific amount of pleasure of a certain type. Each card has its own threshold for the type of pleasure it can withstand. Players add up the pleasure from their cards on the field. Cards with a threshold for a certain type of pleasure lower than the opponent's total pleasure for that type are removed. The goal is to strategically manage pleasure, taking into account the different thresholds for each card, and to eclipse opponent's cards efficiently.

Testing and Tweaking in Rust

To streamline testing, I coded a command-line version of the game in Rust. Then, to test the game balance, I developed an AI player that randomly played cards and generated some synthetic player data. However, an initial hiccup arose – one player ended up with an abundance of the same cards. Initially thinking it was due to card duplication, I realized the problem stemmed from duplicating a random card from the player's deck when drawing, prompting me to implement a tracking system for drawn cards.

Shaping Dynamic Gameplay

A more significant challenge emerged when positive feedback skewed the game dynamics. Removing an opponent's cards led to unforeseen consequences, as the next card played would be wiped out by the leftover cards. To address this, I modified the game so that when all opponent cards were removed, the field was cleared, and the cards were transferred to the discard pile, which then served as the draw pile.

Balancing Act and Field Management

The balancing act became my next hurdle, striving to design cards that cleared the field efficiently without dragging the game on endlessly. To refine this, I modified the game so that only cards played after the pleasure-dealing card contributed to the field clearing. Another issue surfaced, with players running out of cards around the same time they cycled through their deck once. After diligent investigation, I identified the root cause: cards exceeding their threshold were being removed from the game instead of being placed in the discard pile. Correcting this misunderstanding between eclipsing cards and clearing the field, I implemented a system to keep eclipsed cards on the field without dealing pleasure.

Looking Ahead

The journey of developing my sex card game has been a series of discoveries, adjustments, and creative breakthroughs. As I continue refining and expanding upon the game, the lessons learned in the initial stages will undoubtedly guide me towards a polished and enjoyable final product. Stay tuned for more updates on this exciting game development adventure!

Quite Unusual Newsletter #30

We're thrilled to again ask you to dive into the magic with us as we report our progress and keep you in the loop—With this issue we cover the enchantment SwitchLaid weaved over the last 4 weeks, working on a spellbinding evolution of our protag Lium.

During the last 4 weeks the am SwitchLaid worked his magic on the following:

• Protag Concept Art🖼️
• Protag New Base Mesh🧔‍♂️
• Protag Preliminary Rigging🦴
• Protag New Clothing blockouts👕

TeaserTuesday

The journey of a new day begins with the awakening of sight. As Lium finally opens his eyes, the world unveils its colors, and the day's canvas awaits him.