demoth/jake2

Quake 2 java port

• 👋 Hi, I’m @demoth
• 👀 I’m interested in many things, including software engineering, game development, open source games, language learning, DIY, mechanical keyboards, etc...
• 🌱 I’m currently learning cloud computing, machine learning and Svenska language
• 💞️ I’m looking to collaborate on the Jake2 project
• 📫 You can reach me in discord: demoth, email: [email protected]

jake2's Issues

Crash when using console on 4k resolution

Some out of bound exception

Create thin client

create a application wrapper around client module (without game or server modules) that can connect to other servers

Parse server and user into structure

at the moment user and server info are stored as an Ugly string and parsed many times in a single frame

Move to nifty-gui

Replace existing ui code (the biggest class in project) with nifty-gui library

Allow running multiple instances of server on one jvm (Part 2) Server side state

collect server side state into one object tree to be able to run multiple instances of the game

Create Cvar, Cmd and Cbuf registry specific to game instance

cvars, commands and execution buffer should be specific to game instance (at the moment this is GameImportsImpl) and not interfere with other instances

Medic revives his own targets and gets killed by them

Support zip packs (zip, pk2, pk3)

Allow running multiple instances of server on one jvm (Part 1) Game side state

This would require complete removal of static fields usage

Split Defines into module defines and enums

Move game mechanic constants out of source code

Health, damage, radius and similar things should be moved from the source files into a resource file(s) csv for example

Create classes for network commands [Server] [Part1]

now network commands are constructed and parsed piece by piece on both sides
jake2.qcommon.network.NetworkCommands
create classes that can be serialized/deserialized easily from bytestream

without svc_spawnbaseline and svc_packetentities

Split mod (game) logic into pluggable minimods

Quake 2 mods are developed and distributed as one big chunk of logic, combining monster/weapon/item/coop/deathmatch rules, etc..

There are however many parts of the mod that don't interact with each other (like monster logic and weapon logic) and therefore could be isolated. Both code and resources.

This is just and idea and need more refinement

Type safe cvars

Implement type safe cvars (enum, bool, string, int, float) to avoid unnecessary casting and potential bugs

• description

Split Globals into module globals where possible

Support mods

Mods (without game.dll) should be supported via +game command

Create classes for network commands [Server] - svc_spawnbaseline

Both sending & parsing

Get rid of linked lists

Linked lists are all over the place (look for next member of the same type)
For objects that have a unique id move to hashmap, and arraylists for everything else

Create class for client network packet

Parse client network packet into the class

MacOS, openJDK 13, couldn't exec default.cfg, did not execute cmd bind MWHEELUP weapnext

My setup:

^Cbash-3.2$ gradle -v

------------------------------------------------------------
Gradle 6.4
------------------------------------------------------------

Build time:   2020-05-05 19:18:55 UTC
Revision:     42f7c3d0c3066b7b38bd0726760d4881e86fd19f

JVM:          13.0.2 (Oracle Corporation 13.0.2+8)
OS:           Mac OS X 10.15.3 x86_64

The output:

couldn't exec default.cfg
did not execute cmd bind MWHEELUP weapnextdid not execute cmd bind MWHEELDOWN weapprevdid not execute cmd bind w +forwarddid not execute cmd bind s +backdid not execute cmd bind a +moveleftdid not execute cmd bind d +moverightcouldn't exec config.cfg
couldn't exec default.cfg
did not execute cmd bind MWHEELUP weapnextdid not execute cmd bind MWHEELDOWN weapprevdid not execute cmd bind w +forwarddid not execute cmd bind s +backdid not execute cmd bind a +moveleftdid not execute cmd bind d +moverightcouldn't exec config.cfg
did not execute cmd dedicated_start====== Quake2 Initialized ======

Refactor logging

use usual logging library and remove custom logging code

Add documentation to each module

What to highlight:

• each module - add readme with high level description of functionality
• quake file formats
• network communication
• game/server interface

Create classes for network commands [Server] - svc_packetentities

The last network message left to migrate. Shares some code with spawn baseline message

Move to kotlin gradle configuration

switch to build.gradle.kts files

paths with spaces do not work when passed as arguments to jake

if you pass +set basedir '/home/blabla/cool game 2' basedir path becomes truncated

Add unit test also

Create overview of security and stability fixes from r1q2 and q2pro

There are many improvements made in q2pro and r1q2 source ports. Create a list of most important fixes

Implement proper error/exception handling

Remove system.exit usages, fix exception handling

Create new GameImports/GameExports instance every time new map is created

Support quake1 enemies

https://github.com/decino/Q2Infighter

Supertank does not explode after death

For some reason super tank does not call M_Supertank.BossExplode think function at the end of death frame mmove.
here jake2.game.M#M_MoveFrame if monster has a flag Defines.SVF_DEADMONSTER (which it does by the time end frame is reached) neither ai nor think functions are not called

Allow running multiple instances of server on one jvm (Part 3) Server Main changes

Sever main procedures are responsible to manage server instances and clients.

Main challenge - to make clients collection usable by several gameImports/gameExports instances.
Right now gameImports use clients collection exclusively, assuming indexes (1, maxclients) are all clients.

Move to non blocking networking

Reimplement networking code to java.nio or ktor server

Cannot run more than 2 instance of the game

due to port is already used

Profile jake2

Run the game though a profiler and see what functionality is taking most cpu time, memory ets.
Do both for server and client

Create overview of fixes and improvements of gildor2's Quake2 modification

Most of them will be helpful

Try GraalVM

Run jake2 on graalvm to check performance improvement.
Try AOT compilation

Rectify connectionless (out of band) messaging api

Create enums and proper api functions to make such packet sending strict (not just strings)

Move `meansOfDeath` from game state to client (ent)

Since it's a property of a particular client (or entity)

Notarget does not work

Support better textures in tga format

Make personalized player trails

Player trail is a static structure for a single player. Should be personalized for every player (in coop)

Rework monster animation code

Move the enormous descriptions of the animation from the source code (for example in M_Soldier.java) into a resource file. For example json?

Upd. 2024: After reviewing of what is done and what is still achievable, it makes sense now to settle on what is already implemented in the scope of the animation rework and if necessary improve later.

The biggest understanding now is that the decision making solution (which was previously tied to the animation and monster logic) can be done outside of the initial scope of this task (moved to Rework monster decision code #109).

New approach:
Animation is controlled with the state machine. Each state is an animation sequence which can either loop or transition to another state. The transition rules govern which transitions are allowed. The character can interact with the game world (or with itself) via events, which are emitted in certain frames (for example sounds and firing projectiles).
An excerpt from the new animation definition:

        AnimationSequence(
            name = "fidget",
            type = StateType.IDLE,
            frames = (1..49).toList(),
            events = mapOf(0 to "sound-fidget"),
            loop = false,
            nextState = "stand"
        ),
        AnimationSequence(
            name="pain",
            type = StateType.PAIN,
            frames = (100..109).toList(),
            events = mapOf(1 to "sound-pain"),
            loop = false,
            nextState = "stand"
        ),

Split edict into compoments

The edict_t class is a junkyard of different fields used for different scenarios. Split into different components (not a full ECS)

Create classes for network commands [Client]

ClientMessage
ClientMessageType
StringCmdMessage
UserInfoMessage
MoveMessage

Move game related edict fields to another object

Use java String instead of c like char arrays

Get rid of System.exit() usages

Split project into modules

There are several distinctive modules in the project:

• Server
• Client + Renderer/Sound
• Common
• Game

Extract item data from code to csv format

Implement Maptools Part1 - bspinfo