From Idler to Tech Tycoon: Earth

Chapter 25: Realism
Chapter 25 - 25: RealismRichard followed Jack into the kitchen, where the familiar sounds of running water and low chatter filled the space.

At the sink, Anita was washing the dishes, her hands moving with practiced efficiency, while Estello sat at the nearby table, listening to an old radio playing soft, crackling music.

As soon as the two walked in, Anita and Estello glanced up.

”Oh... I thought you two weren’t going to eat,” Anita said, wiping her hands on a dish towel.

Jack pointed at Richard with an amused smirk. ”Tita, Richard was never gonna eat if I didn’t drag him here.”

Estello chuckled, shaking his head. ”You boys are really serious about what you do, huh?” He leaned back in his chair. ”I saw your new office earlier. Looks impressive. But you know... if you’d just told me, I could’ve built you a two-story building right next to the house.”

He gestured toward the grassy plain to the right of the mansion.

Jack smirked, rubbing the back of his neck. ”Not yet, Grandpa,” he said, his tone hinting at something unspoken.

Richard glanced at him, catching the meaning behind the smirk—Jack was planning something bigger.

Anita, oblivious to the silent exchange, set down two plates on the table. ”Anyway, here—eat up before your food gets cold.”

The plates were filled with steaming white rice and a generous serving of meat and vegetables.

Jack grinned. ”Now this is what I’m talking about.”

Richard nodded, pulling up a chair. After hours of coding, his stomach was finally catching up to him.

As they finished eating, Jack leaned back in his chair, tapping his fingers against the table in thought. ”Bro, since our game is just the lite version compared to what we’re actually planning, what kind of resource points mechanic should we implement? Are we going with the usual flag capturing system?”

Richard took a sip of water, considering. ”We could... but I was thinking something more immersive.” He leaned forward, resting his elbows on the table. ”You ever played GTA: San Andreas?”

Jack raised an eyebrow. ”Yeah? You mean that turf war mechanic?”

Richard smirked and nodded. ”Exactly. Instead of players just running to a tiny circle and standing there to capture a flag, we assign entire zones per map. A team doesn’t just ’capture’ a point by standing still—they have to actively dominate an area.”

Jack’s curiosity piqued. ”So, we’re talking about larger, multi-objective control points?”

”Right,” Richard said, gesturing with his hands as he explained. ”Let’s say one zone is a residential district—to fully claim it, players would have to clear out the houses, making sure no enemy squads are hiding inside. Another zone might be a market area, meaning players need to control multiple entry points, rather than just standing in one spot waiting for a flag to change color.”

Jack’s eyes widened slightly. ”Damn, that could make fights way more intense and strategic. Instead of just rushing a flag, people will have to work together to clear out a zone.”

Richard nodded. ”And instead of a fixed respawn cost, we tie it to equipment and weapons. Think about it—older weapons from the early years of the war would cost less resource points, while newer, more advanced weapons, say from 1944, would cost more points.”

Jack frowned slightly. ”Wouldn’t that lead to people just spamming tanks?”

Richard shook his head. ”Nope. Each tank hangar will have a cooldown system. For example, one hangar might be able to spawn five tanks per round, and after that, it goes on a ten-minute cooldown before producing more.”

Jack nodded slowly. ”Okay... but what about new players? Wouldn’t they just suck at using tanks compared to veterans?”

Richard smirked. ”That’s where player progression comes in. Players have to level up their skills with tanks. New players will have slower movement speed, lower accuracy, and longer reload times compared to experienced tankers. The more a player uses tanks, the better they get at handling them.”

Jack laughed, shaking his head. ”Damn, bro. This is some next-level realism. But wouldn’t this level of detail be hard to implement?”

Richard waved his hand dismissively. ”Nah, it’s just scaling. We create different classes, each with base stats. Like an Infantryman class, Artillery class, Mortar unit, and eventually an Artillery Commander. Then we’ve got a Tank Crew class, Sniper class, and so on.”

Jack leaned forward. ”Wait—if we’re including wind mechanics, does that mean sniper stats will affect how they compensate for wind speed?”

Richard grinned. ”Exactly. We can invert the penalty as they level up, meaning experienced snipers will have an easier time compensating for wind drift over long distances.”

Jack let out a whistle. ”That’s epic. So, it’s basically like MMORPG-style classes, but in a realistic war game?”

”Yeah, except items don’t drastically affect damage,” Richard clarified. ”They mostly impact penetration power and accuracy.” He paused. ”But before we start on all of this, we need to implement leaderboards first. Asian gamers, in particular, are obsessed with ranking systems. If we want engagement, we need competitive leaderboards.”

As they continued discussing ideas, Estello let out a loud sigh, rubbing his temples. ”My head’s about to explode listening to you two.” He waved them off. ”Go to your damn office and let me enjoy my radio drama in peace.”

Anita, who was still washing their plates, chuckled. ”I have no idea what either of you is talking about.”

Jack grinned. ”Don’t worry, Tita. One day, you’ll see it in action.”

Richard smirked. ”That is... if we don’t get kicked out of the kitchen first.”

With that, the two grabbed their things and headed back to the office basement, their minds buzzing with new ideas and fresh excitement.

As Richard and Jack headed back to the basement office, Richard glanced at Jack. ”By the way, what were you working on earlier?”

Jack stretched his arms before answering. ”Oh, I was modeling tanks, vehicles, and some defensive structures—stuff like sandbags, dragon’s teeth, tank traps, trench walls, and wooden barbed wire.” He rubbed the back of his neck. ”I also coded some basic mechanics, like player-to-moving-object transition control, leaning, and crouching.”

Richard nodded in approval. ”That’s solid. But I’m guessing you hit a roadblock somewhere?”

Jack sighed. ”Yeah. I was trying to implement a terrain deformation mechanic—basically, I want the Engineer class to dig the ground before placing trenches. But ever since you changed the terrain physics, I’ve been struggling to get it to work properly.”

Richard smirked. ”Don’t worry, I’ll help you with that.”

Jack waved him off. ”Nah, dude, I got this. I’ve been studying your new physics implementation, so I just need time to figure it out.”

Richard chuckled, raising his hands in surrender. ”Aight, aight. Just let me know if you need a hand.”

As they reached the office, the lingering scent of fresh paint hit them. Jack groaned. ”Ugh... smells strong in here.” He glanced at the air conditioning unit. ”Let’s turn this off and air the place out.”

He grabbed a nearby box, propping it against the glass door to keep it open. Then, he switched on the electric fan, letting the airflow push out the paint fumes.

Jack sat down at his workstation, booting up Blender3d, while Richard settled into his own setup, cracking his knuckles.

Richard settled into his chair, cracked his knuckles, and opened his IDE. His project, RenderCore, loaded up on the screen, waiting for him to continue.

He took a deep breath. Time to wrestle with OpenGL.

The first battle? Context initialization.

For hours, he struggled through the complexities of OpenGL’s initialization process.”Pixel format, double buffering, depth buffer... so many options, so many pitfalls. One wrong setting, and the whole thing crashes.”

He tweaked settings, recompiled, debugged. A flicker on the screen—progress. But it still wasn’t perfect.

Next, he tackled buffer creation.

He defined methods like:

CreateVertexBuffer() – to store vertex positions, normals, and texture coordinates.

CreateIndexBuffer() – to organize triangles efficiently, reducing redundancy.

CreateUniformBuffer() – to pass shader parameters like lighting, transformations, and materials.

”Vertex buffers for geometry, index buffers for triangles, uniform buffers for shader parameters,” he muttered as he worked. ”It’s all about allocating memory on the GPU, sending data, and managing it efficiently.”

Another two hours passed, filled with debugging buffer allocation and data transfers.

Memory leaks. Performance bottlenecks. Crashes.

”Direct state access, buffer mapping, persistent mapping... OpenGL offers so many ways to handle data, but each comes with its own trade-offs.”

Despite the frustration, he powered through.

Finally, it was time for the core of the rendering pipeline—Shaders.

Richard opened a fresh file, his fingers already typing. ”Shaders...” he murmured. ”The real magic behind graphics.”

Vertex Shaders – Responsible for transforming 3D points into screen space.

Fragment Shaders – The artists of the pipeline, deciding the final color of each pixel.

Geometry Shaders – An optional but powerful tool for procedural geometry generation.

He began defining the CreateShader() method, painstakingly setting up shader compilation and linking.

”GLSL... a strange language, but powerful. Compiling it, linking it, checking for errors... it’s a constant battle against syntax errors and linker issues.”

A minor typo in his shader code caused an entire screen failure. Black screen.

He sighed. ”Ah, here we go again...”

Time to debug.