Forem: webdva

Once Proprietary and Private Technology, Now Open and Public

webdva — Fri, 10 Jan 2020 04:19:08 +0000

I open sourced the 3D multiplayer browser game.

https://github.com/webDva/3d-multiplayer-browser-game

So if you ever wanted to know what all the internals of the 3D multiplayer browser game I was making looked like, this is your opportunity to see! I guess I'm a real typical startup founder now where I decide to pivot and give away ownership from a failed endeavor. This particular video game product went through many changes, like it was supposed to, but all for the final end and show (a spectacle!) of unfavorable action. For no revenue was obtained—the achievement of revenue, the goal of the business—before the time limit was reached. Nonetheless, the profound technology entrepreneurship experience was essential and it will come in handy in future conquests and successes.

A Resolution for Better Years on Earth

webdva — Mon, 09 Dec 2019 16:19:58 +0000

An important exposition on a telos to escape the totality of a certain traditional context.

I declare and assert that a metaphysical halt and reassessment is needed for the Prosperity program—that the metaphysics of the present process of improving my socioeconomic status is in dire need of careful examination which may cease all current tasks. Specifically, my “What product should I make?” and my “Who should be my target market?” were terrible and deficient questions to ask, entailing an ultimately fatal will to truth of common mediocrity. I was wrong, metaphysically. Metaphysically I was, but my reasoning abilities were flawless in the physical realm of things due to my skill and devotion to reason. The foundation of the Prosperity program’s being was poorly constructed and inspired by bad and foul desire, a becoming of the world that you should conceive of as being no different from an engineering structure or subject built based on erroneous assumptions. Thus, my noble effort rightfully came crashing down, as it embarrassingly is, before it could even soar into the sky of great heights. I must bravely admit and reveal that scientism’s feeling of power granted to me (a childish, young, and very naïve me that you could imagine to be here) by its commonly bestowed human and personal identity of being knowledgeable and of having a consistent methodology, influenced and vitalized by the deceptive and betraying persuasion and appearance of the Cartesian Cogito, ergo sum upon which such dogmatism—one whose asserted propositions and hidden presumptions sustain only a decadent and weak spirited life that starves for any valuable nourishment—is contingent, empowering the human subject’s truths, faiths, and certainties, was a large determining factor of my unfavorable behavior and performance. I apologize to any spectators who may have looked upon me with curious and innocent reverence and for spiritual guidance, for I have failed to achieve a success of acceptable valuation. I promise that next time, as I shall try again, any scientific, engineering, physical, or empirical pursuit will not have its approach, methodology, and strength be developed independently from sound philosophy and metaphysics. Better questions will be asked. More segmentations of understanding and knowledge will be critiqued, with high performing skepticism, and certainties placed under great scrutiny. Paradigms and conceptual frameworks where the dominance of the atomistic subject is cherished and emphasized will be carefully regulated to allow more flexibility in results. Henceforth, reconstruction of all my entrepreneurial activities now begins with a healthy spirit of true and great progress. The Prosperity program’s objective was to converge to a local optimum, but it would undoubtedly and necessarily be asked “To what, exactly and ultimately?” and “What is the underlying essence of such convergence?” A new perspective is needed where the logical reasoning toward a foundation of existence is actually invalid and never considered at all in the first place. This is for the sake of establishing a future founded on a better foundation.

Q2 2019 Report

webdva — Sat, 06 Jul 2019 14:56:21 +0000

The report for the second quarter of the year 2019.

Game Development

I continued developing the commercial 3D multiplayer browser game that was started up in the previous quarter (Q1 2019) of the year. Some aspects of the game product's creation:

I implemented health bars for a 3D game, an achievement to note because of the technicality of displaying a two-dimensional planar object that always faces the viewer/player inside a three-dimensional space. This was made possible in part by the nature of the commendable Babylon.js game development framework (which was used to make the game) and the wealth of resources provided for its use.
Similarly, I achieved having visible player names that are displayed above players' heads (identifying them for other players) for a 3D multiplayer game, which is a common requirement for 3D multiplayer games. Also, the player names are randomly generated on the server side.
I achieved having 3D models attached to other 3D models, such as having characters holding weapon items in some manner.
I gained experience in using procedural animation for player characters' attacks.
I prototyped and achieved role-playing game (RPG) classes with stats-based damage calculation and real-time 3D multiplayer action RPG combat.

I created rudimentary artificial intelligence behavior for nonplayer characters (NPCs) with attacking and aggroing and de-aggroing functionality.

I achieved and implemented leveling or progression functionality/mechanics.

Cancellation

Multiple issues plagued the development of the 3D multiplayer browser game. There was an actual lack of entrepreneur-customer fit: despite my great commitment to players and gamers, I was unable to find a solution that would benefit both of us, me the entrepreneur and players the customers. The monetization of the proposed and budding free-to-play game product warranted great consideration due to the ethical implications of the planned monetization strategy that conflicted with my integrity, my compassion for players.

As such, the 3D multiplayer browser game has been abandoned in favor of better solutions. Note that no technical problem that arose posed an actual risk to the project's success.

Do not fret, however. The data, knowledge, lessons learned, experience, documentation, and technology obtained from the 3D multiplayer browser game's development is being converted to utility for the success of a new endeavor. Furthermore, note that it is possible for me to release or even open source the game (with its associated documentation having to be shared along with it) for the purpose of helping to facilitate the spread of free knowledge and technology so that others may benefit. But there is no need to do so.

Current Tasks

I recently discovered, thanks in part to my game development experience with Euler angles and quaternions in the previous quarter (Q1 2019), the utility of abstract or pure mathematics and I am now engaged in a new initiative that involves me learning and studying mathematics, abstract mathematics even, which is often the theory behind the theory, to find from there--as therein lie the secrets of the world, the arcane and mystical arts--an idea with which to successfully start up a business with the achievement of revenue, however slight the revenue. This has to all be done in less than six months, by the way, before the end of the year 2019, before the start of the next decade.

I have faith that such an innovative, yet risky, process will work and that it will turn out well in the end for me and I'm eternally committed to ensuring that the favorable end does occur, being responsible for my envisioned success and commanding its arrival.

The Future

With the current infrastructure being built and established--because that's what I've been essentially doing this whole time as an entrepreneur with all my "successes" and "failures," "lessons learned," etc.--I'm going to perform great deeds with such utility in my possession.

One of my ambitions is to give rise to entire new industries and jobs, prosperity for all. That's the kind of entrepreneur I am becoming.

So it's imperative that my Prosperity program is successful as it will enable me to begin to perform such a large deed, just as the success of the Apollo program of yore proved that the United States and its system of freedom and democracy was more capable than that of its antithesis. May I too converge to a nondominated solution of unprecedented heights, for efforts to change the world can be considered to essentially be multiobjective optimization problems.

I need only do the right thing, which is to succeed, facilitated by courage, integrity, and strength.

I do not seek an inconsiderate disruption of anyone or anything. I only wish to engineer a future of prosperity for the world and for myself to diverge from a dominated socioeconomic status. I am prepared to fulfill any role and perform any task that the world requires of me so that this duty may be fulfilled.

And it appears that I must play the part of the innovator who traverses previously unexplored spaces without a role model to follow or useful literature to refer to, without the aid of anyone else as no one else is able to help me because no one else has experience with such spaces, knowing what is the right thing to do. As such, I must envision--I must create--the future me that will function as that role model and I must create my own literature of success. With these obligations that are of my own volition and design, I effect a self overcoming. This is what I have found myself in, faced with such unprecedented challenges that require equally exceptional courage and strength, as the me of the past when I began this entrepreneurship journey undoubtedly did not expect such responsibility and profoundness.

Nonetheless, I'm starting up a business and it is a great investment in my future, so I'm fully committed to its success.

For the sake of the future.

A new endeavor to reach the next level

webdva — Sat, 22 Jun 2019 22:48:36 +0000

I find myself on a new endeavor, as the previous one was simply the wrong thing to do, while on my quest to mend the world.

On the road to success I will have no friend as my duty requires me to banish such things from my life. A duty that is mine alone and no one else's for my ambitions are mine alone and no one else's. In this endeavor, there is only me and these mathematical objects of my study, abstract insentient beings who command the world I seek to conquer.

This endeavor, where now the answers I now seek can be found in books, calls for me to find ideas not from the world that my physical form is well acquainted with, the reality that you love so very much and have created a comfortable abode in, but instead, yet another new world whose truths enjoy great sovereignty over our realities. A world whose lands have only been scarcely mapped by the few men and women who dared to survey it.

It is the world of the advanced sciences' insentient lawgivers and commanders who determine what is exactly what along with the why and the how.

A world of great power that even you have a natural instinct toward. Its allure can easily tempt you toward its empty embrace and it ultimately does seduce you, should you decide to answer its beckoning, leaving you at its freezing cold mercy.

A world that requires the same essential courage that our predecessors had. Their same essential strength.

A world that I must venture in so that I may extract its utility for my benefit: the success of the Prosperity program before this year ends. A success and goal that is simple: to achieve a nondominated socioeconomic status, a local optimum of prosperity, as having a dominated socioeconomic status is simply unfavorable.

While learning advanced sciences and mathematics for practical applications, you do not really directly compete with other participants, especially as few dare to venture into this world. You instead only compete with yourself, your past self, for the sake of your future self and at the expense--the suffering--of your present self.

These are simply the requirements for the success of this endeavor.

A quick update on the 3D multiplayer browser game's development

webdva — Fri, 17 May 2019 00:39:02 +0000

In addition to doing extensive game design, I've been doing game development as I must perform many tasks myself.

Nonplayer characters

I made progress on the main aspects of the nonplayer characters (NPCs), such as how they behave.

If I keep this up, working on such a thing as NPC behavior, then I'll be able to employ real artificial intelligence (or machine learning) for such a game product. Because, let's not forget that this program, this effort, is an investment in the future and in future capabilities, in addition to its noble goal of facilitating convergence to a local optimum of prosperity before this decade is out.

The NPCs are, like, really at the center of this game idea. Even though it's a multiplayer game--and because it's a multiplayer game with a particular goal which involves having acceptable user retention among others. Let's just say that I don't intend to make the same mistake with such things that developers of multiplayer games often do.

An archer class and unexpected complexity

I made an archer class to go alongside the warrior and mage classes.

In the above screenshot, the archer's attack fails to damage one of the targets. The archer's attack failure may be because of the low update rate of the game combined with the high speed of the archer's projectile attack. And so, high speed attacks are prohibited for the current configuration and design.

Thanks to this recent experience, I have discovered, firsthand, that the development of a multiplayer game that uses action combat is much more complex, difficult, and expensive than the development of a multiplayer game that uses tab targeting like most MMORPGs. So this game won't be an action RPG game.

So these recent achievements seem to be prototypes for the final design.

An Entity-Component System

When I originally started up this 3D multiplayer game, I chose the specification of forbidding myself from using an Entity-Component System. The reason was that I wanted this game product to be simple enough to not warrant the need for an Entity-Component System.

But here I am, creating such a thing, which was unexpected.

Socioeconomic aspects

This product I'm making isn't entirely a technological endeavor because it's a game with the requirement to satisfy a certain type of market's demand. Nonetheless, I will ultimately succeed, before this decade is out, in making this product and establish revenue with the achievement of product-market fit.

Furthermore, this development log isn't really a high utility factor as my likely and true target audience for this product doesn't even consume such content. It would be a negative utility factor to rely on this blog/codex for marketing this product. As such, I'm going to decrease the amount of these development updates so that I can devote more effort to the product's success.

Now, I currently have two great problems to solve.

As I am, first and foremost, an entrepreneur who treads an extraordinary path with a powerful mind and will, who (as in what market) should I serve? And what (as in what game product) should I make for them?

Q1 2019 Report

webdva — Mon, 01 Apr 2019 19:37:30 +0000

The report for the first quarter of the year 2019.

Game development effects and achievements

I further improved my 3D modeling abilities.

I further improved my 3D animation abilities.

I achieved an implementation of client-side linear interpolation combined with client-side prediction for a networked multiplayer game.

I gained the capability to create and use shaders. I published a reference for constructing shaders.

I achieved collision detection for a networked multiplayer 3D game.

Product development

I began development of a 3D multiplayer browser game that went through many iterations.

It first looked like this, a game with RPG combat:

And then it looked like this, an innovative pseudo-massive multiplayer flying shooter game idea:

Engineering and scientific capabilities gained

I achieved the implementation for a conditional front-end browser source code minification system.
I learned the concept of affine transformations for 3D game development, including movement along a forward facing vector and position translations in three dimensional space.
I gained the capability to achieve rotations in three dimensional space for a 3D game, involving the knowledge of Euler angles and rotation matrices.
I gained an understanding of quaternions.
I learned new mathematical concepts such as the hyperplane separation theorem for implementing collision detection with oriented bounded boxes in three dimensions.

Strategic commercial activities

I planned to enter the modern browser game market space to obtain a portion of that market share in an effort to accomplish the Prosperity program's goal of establishing income as a technology entrepreneur before the year 2020.
I failed to achieve the Initial Product Release of a 3D multiplayer browser game before the end of the quarter.
I considered a pivot from the business-to-consumer segment of game development due to a possible lack of founder-customer fit. Due to a set of cognitive biases and distortions, I actually may have been mistaken about the value of such consumer markets to me as an entrepreneur.

Personal aspects/Operating agent status

I discovered and adopted the utility of eternal optimism. I now bear all the utilities needed to meet the requirements for having the right stuff.

Summary of the quarter

I worked on the development of a 3D multiplayer browser game and obtained very useful capabilities. I am now in possession of more advanced technology, knowledge, and processes than what was had in the previous quarter (Q4 2018).

Predictions

Short term

With a great commitment to the Prosperity program and to doing the right thing, the Prosperity program's success will be achieved, which is, ultimately, the convergence to a local optimum of prosperity.

The far future

Greater courage, integrity, commitment, and other treasures will be obtained. Greater nondominated solutions will be converged to and lesser dominated states diverged from.

With the predicted post-Prosperity assets and capital that will be obtained, I will be able to eventually establish a far-reaching enterprise that engages in experimental physics and mend the world in innovative ways.

A Proposal for Achieving Oriented Collision Detection

webdva — Fri, 15 Mar 2019 18:20:41 +0000

I have an idea for a simple solution for accounting for orientations in collision detection that occurs in three dimensions.

This is in consideration of an idea for a pseudo massive multiplayer online game with Dark Souls like combat.

Due to the nature of Dark Souls's combat which involves the swinging of melee weapons, the orientation or rotation of the hypothetical weapons would need to be accounted for to provide accurate collision detection.

An issue to consider is the art style which would affect many aspects of the game.

Inspired by the very intelligent and impassioned game develeoper named Dek, his game Hordes.io uses an innovative and simple art style for the characters.

For the proposed hypothetical game with Dark Souls like combat, each weapon would be entirely composed of a simple rectangular box. If the proposed simple art style is used, it would facilitate very accurate collision detection due to the collision boxes being the exact same shape and size as the hypothetical game characters and melee weapons.

Technical implementation proposal

I propose a possible solution to achieving collision detection between two collision boxes in three dimensions with orientations accounted for: using affine transformations to transform the coordinate frame of one collision box's vertices to that of the coordinate frame of the other collision box.

Using the transformation operators T1, representing the original coordinate frame of the collision box to transform, and T2, representing the coordinate frame of the second collision box that it will be transformed into, on the column vector x1 that is an untransformed vertex point of the first collision box will look like

with whatever the true four-by-four matrix multiplication order and direction is. The new vector point x2 would then be useful for determining if penetration between two oriented collision boxes has occurred.

This should be a simple solution and it looks almost naive-like which is very desirable.

I do not know if such a method or solution will achieve its intended effect and I would thus need to actually experiment and see if it would work and that the hypothesis of simply using affine transformations to achieve collision detection that accounts for orientations is true.

Practical considerations

However, real world constraints currently prevent such an action of experimentation from being easily performed, such as not having the privilege of a testing space or environment, with using pen and paper being the best that I can do right now, and being limited by the Prosperity program's driving time constraint which must be considered in all decisions.

Note, though, that the driving time constraint can allow the resulting flexible performance constraint to be exploited, such as by allowing the decision maker (me) to deem inaccurate collision detection to be acceptable which may result in orientations in the collision detection system not be accounted for at all, for example.

I achieved 3D collision detection

webdva — Sat, 02 Mar 2019 17:15:24 +0000

I was able to easily and quickly implement this functionality in part due to the experience and technology I acquired during this whole multiplayer game endeavor. I won't be detailing how I implemented collisions in three dimensions, so this won't be a very technically informative entry.

The 3D collision detection subsystem uses axis aligned bounding boxes (AABB). Rotations are not accounted for.

What's happening in the above screenshot is that, as a projectile sphere collides with the player avatar, the server reports that a hit has occurred.

Here is another instance which somewhat demonstrates the accuracy of the hit detection:

But there are some issues that must be considered:

A hitbox shares the same position and movement translation as its assigned parent game object, but it does not rotate at all.
A hitbox's size and dimensions are invariant. As such, as the hitbox does not rotate but its parent game object does, the invariant size and dimensions of the hitbox can cause an issue with the accuracy of collisions.
A hitbox is a box whereas the projectiles are currently spheres, another accuracy issue.
3D model creation and thus accurately determining the appropriate size for hitboxes on the game server is problematic.

Nonetheless, this new system element currently functions as an asset that will be used to achieve essential effects.

A Very Brief Introduction to the Construction of Shaders

webdva — Mon, 04 Feb 2019 04:20:58 +0000

This codex entry functions as documentation and as a reference manual for me when I create shaders. Note that there may be some discrepancies but it still suffices as a resource.

Fundamentals

The goal of the shader construct is to achieve graphical effects such as mesh deformation or recoloring. A shader performs operations first using the positions of all the vertices of a target such as a 3D model or 2D texture and then on the colors of the processed vertices. The portion of the shader that operates on the positions of the vertices is called a vertex shader and the portion of the shader that operates on the colors is called either a fragment shader or a pixel shader.

Shown below is the source code for a vertex shader program.

#ifdef GL_ES
precision mediump float;
#endif

precision highp float;

// Attributes
attribute vec3 position;
attribute vec2 uv;

// Uniforms
uniform mat4 worldViewProjection;

// Varying
varying vec2 vUV;
varying vec3 vPosition;

void main(void) {
    gl_Position = worldViewProjection * vec4(position, 1.0);

    vUV = uv;
    vPosition = position;
}

An initial segment that is C preprocessor-like

As the programming language used to create a shader is a language that is like the C programming language, and like in C, a shader program can be configured with a segment of code located at the beginning of the program. The shader programmer can define constants here like the value of pi.

Mobile devices support

#ifdef GL_ES
precision mediump float;
#endif

The preprocessor directive here instructs the shader program to use a lower precision for floating point values with the condition that the shader program is running on an OpenGL ES device which means OpenGL for mobile devices. This may cause a graphics quality difference between desktop and mobile versions, but this is to be expected as mobile devices often have greater performance constraints than desktop machines.

A paradigm for understanding attributes, uniforms, and varyings

An attribute value can be thought of as literally an attribute of the current vertex, such as a position, namely attribute vec3 position. Note that for the shader that we are using here, the CPU (or more pragmatically, the application that uses or calls the shader program) is supplying information from a 3D model and 2D texture to the shader program.

A uniform value can be thought of as, with the meaning of the word uniform being constant, a value that all the vertices or pixels will share as the value is the same for each vertex or pixel that the shader performs on, such as the current time elapsed since the shader program was started.

And a varying can be thought of as a means to supply information from the vertex shader to the pixel shader, such as, literally, an attribute of the current vertex. The vertex shader will usually just calculate the position of the current vertex that it is performing on and then supply this information to the pixel shader as a varying, which is what this particular vertex shader only does.

`attribute vec2 uv;`

I don't know all that is needed to be known about the word UV, but from my Blender model texturing experience and the context, I infer that the uv attribute is a mapping of texture and 3D mesh coordinates. So the vertex shader, especially as the uv attribute value is assigned to the varying vUV variable, passes each different texture-coordinate mapping to the fragment shader so that the fragment shader can operate using the mappings, particularly applying the 2D texture to the 3D mesh.

Calculating the position

The uniform mat4 worldViewProjection variable is a particular value that is the world matrix multiplied by the view matrix multiplied by the projection matrix which will not be discussed here in this documentation entry. The vertex shader calculates and determines the position of the current vertex with the line

gl_Position = worldViewProjection * vec4(position, 1.0);

Accompanying pixel shader

In conjunction with the use of the above vertex shader, here is the accompanying pixel shader.

#ifdef GL_ES
precision mediump float;
#endif

precision highp float;

varying vec2 vUV;
varying vec3 vPosition;

uniform sampler2D textureSampler;
uniform float time;

void main(void) {
    gl_FragColor = texture2D(textureSampler, vUV);
    float distance = length(vPosition.xz - vec2(0.0, 0.0));
    if (distance >= 3.0 && distance <= 3.5) {
        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
    }
}

Selection circle

These two shaders are actually used to create a selection circle, a graphical effect where a circle appears around the bottom of a selected 3D model. As an example of what that looks like, my latest game shown below uses a selection circle effect (albeit a shader was not used to achieve it):

The theory for creating a target selection circle was obtained using this resource: link. The goal is to obtain all the verices on a horizontal plane that are of a certain distance from the center of the target and then to color the collected vertices. As a selection ring, the width of the line of the ring must be greater than one pixel so that it may be noticed which was not specified in the resource.

`uniform float time;`

The time variable is not used in this shader, but I'm letting it serve here as a reminder that it is provided by the CPU or caller of the shader to tell the shader how much time has elapsed since the shader has started running. It can be a different name like u_time, for example, as shown in the Book of Shaders learning resource.

Applying the texture to the mesh

The vUV model-texture mapping variable that was passed by the vertex shader to the pixel shader for the current portion of the 3D mesh is used to apply the originally intended 2D texture color to the 3D mesh with the line

gl_FragColor = texture2D(textureSampler, vUV);

Creating the selection circle

The length function, as it returns the length of a vector, is used to obtain the distance between the center of the 3D mesh and the current fragment's position in the x-z plane.

float distance = length(vPosition.xz - vec2(0.0, 0.0));

Then a conditional, if (distance >= 3.0 && distance <= 3.5), is used to determine if the current fragment's position is of the correct distance to be colored. The shader uses the color green.

gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);

The result

The shader works on terrains with varying heights and it overlays the color onto the terrain as shown with the hill portions being colored.

One negative thing about the use of this shader is that it can show unintended artifacts of its process. For instance, if the model was a 3D cube then it would be clearly noticed. But a ground terrain often doesn't overlap with itself, so it's a non-issue.

How I Implemented Client-Side Linear Interpolation

webdva — Sun, 20 Jan 2019 07:30:31 +0000

As I'm committed to developing a great game for players, I made a simple client-side linear interpolation subsystem for the new 3D multiplayer browser game I'm making.

Background

In the context of physical movement, the transition between an object's initial position A and a target position B can be interpolated causing a smooth-looking transition between the two positions. Linear interpolation is a means to achieve this smooth transition effect.

The following equation shows how linear interpolation determines its effect, with position being the resulting position, start being the initial position, end being the target position, and time determining the length of time of the effect.

The linear interpolation implemented as a JavaScript function which the client-side linear interpolation subsystem uses:

function lerp(start, end, time) {
    return start * (1 - time) + end * time;
}

Note that the word lerp is short for linear interpolation and that the verb to lerp means to do linear interpolation.

The interpolation function can be modified to use more than a linear interpolation, but the simplicity of linear interpolation and its low cost of development has caused it to be the choice that best satisfies the program's constraints.

Also, for documentation purposes and for creating predictive models that will be used in future game development endeavors, note that it took three hours (if I remember correctly) for me to implement this client-side linear interpolation subsystem.

Meeting system requirements

I wanted a smooth transition between an object's current position and its new position as given by the game server on each server transmitted game state update.

The start value will be the object's current position value. The end value will be the server's transmitted new position that it has determined for the game client.

The time value will be determined by the ratio between the time elapsed since the last frame and an arbitrary lerp time factor that will affect how long the movement interpolation will occur.

Using this proposed time ratio will achieve the desirable effect of having a smooth transition between object positions and thus meet system requirements.

Using these proposed utilities, theoretically, if zero time elapsed since the last frame, then the object's position would remain the same, not changing, as evidenced by

which is desirable and meets the system requirements.

Conversely, if the time elapsed between the last frame was equal to the lerp time factor, then the object's new position would be at the end value, as evidenced by

which is also desirable and also meets the system requirements.

A contingency for late frames

If the time since the last frame exceeds the lerp time factor, then the position is simply instantaneously changed instead of being linearly interpolated. A simple if conditional is used to determine this.

if (time_since_last_frame > lerp_time_factor) // do not use linear interpolation
    position = server_updated_position;

Implementation

Below is a stylized implementation of what the simple client-side linear interpolation subsystem uses.

if (time_since_last_frame <= lerp_time_factor) { // use linear interpolation
    position = lerp(position, server_updated_position, time_since_last_frame / lerp_time_factor);
} else { // do not use linear interpolation
    position = server_updated_position;
}

Note that the physical movement in the actual game is actually frame rate independent and has been presented here as being dependent on the frame rate for the reader's sake.

The results

The picture shown below is a comparison between no linear interpolation being used and with linear interpolation being used. The left side shows jerky or disconnected movement as no linear interpolation is being used there while the right side shows a smooth transition between positions, per system requirements, with linear interpolation being used.

Client-side prediction and rubber banding

So as to not wait on the game server for new coordinates to be transmitted as network latency can cause delays in client-server communication, as the player issues a movement command, the game client immediately changes the player's position before it receives the correct position from the game server, predicting what it will be for the player's benefit. The linear interpolation subsystem will then smoothly correct the player's position during the next frame when the client receives the actual position from the server.

In conjunction with the use of this client-side prediction, when the game client loses its connection to the game server, a rubber banding effect occurs during player movement commands where the player's avatar behaves as if it was rubber banded to its position due to not receiving server position updates and thus always lerping between its current position and its predicted position until the connection to the server is reestablished.

Note that this rubber banding effect occurs and is less exaggerated during periods of network subsystem jitter. This is to be expected as it is common for networked multiplayer games that use linear interpolation.

Final Gemini Project Report

webdva — Sun, 13 Jan 2019 00:25:06 +0000

The Gemini Project has served its purpose and is now completed. Due to the combination of the project's very generous and flexible performance constraint and its driving time constraint, I have determined that I have enough science, experience, and technology needed to develop a 3D multiplayer game.

This final report will include a possible solution for dealing with the 3D level creation issue and a note on the relevance of 3D transformations.

Creating 3D levels with metadata using Blender

3D levels or maps can be created in the Blender 3D modeling utility. Objects such as doors that can open and close would need to have properties associated with them so that this object-property mapping can be used by a game engine to facilitate intended game logic. Before the mappings can be used by a game engine, there must first be a way to extract the object properties from a Blender created 3D level. The following is a proposal for such a method of creating 3D levels with metadata using Blender.

Creating properties for the objects/entities in a 3D level

I do not know, but I think that the properties for an entity in a 3D level can be created and handled using the Python-Blender programmable interface console, if I cannot do it using the default Blender user interface for each entity-property mapping that is to be created. This would be tedious and made doubly so because of Blender's apparent (not really what I think) cumbersome interface, but it would be viable and sufficient.

Python utility for exporting entity-property mappings

Since Blender allows 3D entities to have a programmable interface with the use of the Python programming language, a Python script can be created to obtain the metadata of a 3D level. In particular, we can create a Python script that exports the 3D level's metadata to a file with a format such as JSON.

Here is Python source code technology that someone kindly shared freely that can help facilitate that utility:

import bpy
import json

def create_json():
    json_dictionary = {}
    json_dictionary["entities"] = []

    # obtain each 3D object in the level and retrieve its properties
    for obj in bpy.data.objects:
        entity = {"name": obj.name}

        # essential object position, rotation, and scale properties
        entity["position"] = {"x": obj.location.x, "y": obj.location.y, "z": obj.location.z}
        entity["rotation"] = {"x": obj.rotation_euler.x, "y": obj.rotation_euler.y, "z": obj.rotation_euler.z}
        entity["scale"] = {"x": obj.scale.x, "y": obj.scale.y, "z": obj.scale.z}

        # metadata for custom aspects of the object
        if len(obj.keys()) > 1:
            for k in obj.keys():
                if k not in "_RNA_UI":
                    custom_property = obj[k]
                    if isinstance(custom_property, int) or isinstance(custom_property, float) or isinstance(custom_property, str):
                        entity[k] = obj[k] # if the property is actually a valid property, then create a mapping
        json_dictionary["entities"].append(entity)

    return json.dumps(json_dictionary, indent = 4, sort_keys = True)

Blender allows its graphical user interface to be modified with its Python programmable interface thereby allowing the entity-property mappings to be extracted during editing. But I do not currently have the capability to implement such a Python-Blender graphical interface modification. So this proposed method will require the user to always first save the file to disk and then instruct the Python script to extract the level metadata from the Blender file on disk.

3D Transformations

I've begun developing technology for a 3D multiplayer game. Committed to the Gemini Project's goal of making discoveries, I created subsystem prototypes to investigate and determine their feasibility in certain conditions and to create predictive (mental) models that can be used to achieve program and system success. One such subsystem involves the transmission of coordinates between a server and client in a 3D context.

Behind the scenes of the .gif below, the subsystem consists of the player client sending to the server the map coordinates that the player 3D mesh intends to travel to which is determined by the location of the mouse cursor.

The .gif shows that the direction of travel of the 3D mesh as well as its final position after each movement is completed is not aligned with the mouse's location on the grid plane, thereby causing the 3D mesh to not move in the player's intended direction nor to the intended location. I believe that the cause of this may be that the client is sending to the server coordinates from a local space instead of the global space of the scene.

From this, I infer that an understanding of transforming vectors from one vector space to another is essential for operating in a 3D environment. Also note that not much effort is needed (for me) to understand 3D transformations as I have discovered that a 3D transformation is only a process that consists of having four-by-four matrices being multiplied by appropriately sized matrix multiplicands.

The conclusion of Project Gemini

With this current data, technology, science, and experience that I now have pertaining to 3D game development thanks to the Gemini Project, I can begin to develop a 3D multiplayer game. Not only is this an engineering endeavor, but it is also a commercial one with the primary goal of establishing revenue and a means of income as a technology entrepreneur before this decade is out. Not only is this a long and daring journey with a high technical complexity, but it is also one with a complex market space that must be successfully operated and navigated in. This is not to mention the hyperparadigm that these two paradigms or systems are a part of, which calls for systems engineering and systems thinking skills that only champions possess.

I have about one year of experience as a full-time indie maker, and the valuable lessons learned and startup experienced gained from that are being used as utility factors for achieving program success. But the core essential utility factors are courage, commitment, strength, and integrity.

If I fail, it would be because I did not have what it takes to be an entrepreneur, that I did not have the right stuff.

But I have said that I have what it takes. I have said that I have the right stuff. My word is my honor and I have the courage to uphold that honor, despite anything, as that is my integrity and constitution.

The Results of my Fourth Quarter of the Year 2018

webdva — Tue, 01 Jan 2019 14:39:08 +0000

A compilation of the activities that I engaged in during the fourth quarter of the year 2018.

Activities worthy of notice

I discontinued the Pantsu versus Baka project. As a result of the Pantsu versus Baka project:
- I further gained experience in marketing and media manipulation. I discovered the strategy of the combination of inbound and outbound marketing.
- I began to adopt the process of creating comprehensive documentation for systems and integrated this into my startup process.
My systems engineering and project management skills improved and entered a new phase.
I made the Spooky Thing Halloween game being driven by market and consumer data.
I promoted sanitized versions of my How to draw a line in D3.js and How to perform text classification using supervised learning tutorials on the Dev.to online community platform and achieved excellent effects.
Leveraging the marketing knowledge and experience that I gained in the previous quarter (Q3 2018), I gained a foothold in the Reddit social space and began a clandestine, slow, and delicate Reddit influence and presence expansion campaign.
I discovered that I had a detrimental bias toward marketing due to a set of cognitive distortions and cognitive biases and then I began to modify my startup process to allocate more effort to the engineering of the product for this current phase.
I achieved the Initial Product Release of my first multiplayer game.

Networked multiplayer browser game development

I learned the socket.io framework for creating web applications that require real-time bidirectional event-based communication, namely for creating networked multiplayer browser games.
I discontinued the use of the socket.io framework and migrated to the ws Node.js WebSocket library and simultaneously learned the browser native WebSocket API.
I learned about typed arrays in JavaScript for creating binary data protocols for multiplayer browser games.
I gained the capability to develop simple multiplayer browser game server technology and I am now in possession of newly created multiplayer browser game server technology.
Leveraging my newly gained multiplayer browser game development skills and knowledge, I began conducting research for the sake of gaining the means to develop large scale persistent multiplayer games.

3D game development

I gained the capability to create basic and suitable 3D models and animations using the Blender 3D modeling and animation utility.
I began learning and operating the Babylon.js 3D game development framework utility and gained the capability to develop 3D browser games.
I started up the Gemini Project to provide the means and experience needed to develop a 3D multiplayer game. And as a result of the recent progress of the Gemini Project, I am currently in possession of newly created documentation and technology related to 3D game development.
I created my first ever area of effect attack for a 3D game with new hit detection technology that will be used on the server side of the planned 3D multiplayer game. In the .gif below, when the player gets within range of the dummy target box and uses the attack, a hit is registered as indicated by the dummy target box changing color.

A look through the systems thinking paradigm

The probability of my endeavor's success has increased from the previous quarter (Q3 2018) being governed by the nature of the mission success factor predictive mathematical model

with P(S) being the probability of success for an endeavor where s is the number of dimensions of complexity associated with the endeavor with s > 1, t is the time elapsed for a particular point in time of the endeavor, and c is the combined value of complexity of all the complexities associated with the endeavor with c > 0.

In addition to the probability of my endeavor's success slowly but surely increasing as time progresses, my endeavor's probability of success is being further increased with the successful optimization of my utility factors. Utility factors which include integrity, strength, courage, and commitment.

Predictions

Short term

With great struggle and endurance, I will achieve the Prosperity program's success with its goal being the establishment of a modest amount of revenue as an independent hacker before the year 2020.

Long term

After I achieve the success of the Prosperity program, a decade long grind with the goal of obtaining even greater rewards as a technology entrepreneur will begin, as though I were grinding for a high score in a video game, especially as I play to win. The utilities gained during the Prosperity program will be used for the success of that post-Prosperity campaign.