The symphony-of-empires's discuss from symphony-of-empires

Dynamic music system

[Client-side]

The music system will basically play music [no shit sherlock], but should also have "event-themes" which can only play in certain circumstances [for example, prussian music when playing prussia]

Host cannot ban/kick players currently

Leaders for units

Generals and navy generals that commands a unit, they can be transferred to other units and so forth.

The player may recruit a leader from any POP type, their name would then be derived from the culture they come from
A leader may be a general or admiral (technically no difference between them)
They should have some randomized stats which gets higher when the literacy is high and they would also be boosted by technology and inventions

Game loop is independent of client loop.

The main game loop (which hosts the economy, pop growth, etc) is run as:

run = 1;
while(run) {
    LuaAPI::check_events(world.lua);
    world.do_tick();
}

While the client-side thread is completely separate from this (see main.cpp lines 28-35). As it stands, this means a few things:

The client cannot pause or otherwise interact with the main loop. This means for example that there is no way to build in a pause button in the client, as this cannot affect the main loop.
The game loop does not ask the client whether or not it should start, rather, it just starts running as soon as the client starts (or even before that!). This means that if the client wants to present the player with something like a main menu, or an option to load an earlier save, the game will start running in the background nonetheless. As soon as you hit "new game", the game isn't "new" anymore, because the game has already been ticking in the background.
When the client is closed, the main loop is still running, meaning that the only way to close the application correctly is to kill it from a command prompt or terminal. (Conversely, the main loop does wait for the client to close after it is done running, but there is still nothing that can cause the main loop to stop apart from a system interrupt). This is wrong, the client can close the game via extern std:atomic<int> run;.

When a factory is deleted the products of it causes a segfault because they are not yet deleted properly

Open new factories

Really now all factories are static and never change in the game

Damage buildings due to bellic conflicts

Basically in order to repair damaged buildings (damaged buildings underperform depending on how severe the damage is) - it requires a random set of materials to be supplied.

Those random materials should only be one of the ones used to originally build the building

Main menu

Load the "core" essential UI stuff
Have some image as background
Be able to connect to a server or do a multiplayer game (in such case a server is automatically started)

Fix ui scrolling

We need to be able to only show half a widget

Leaked memory everywhere and most of it isn't freed

Automatic label/country name placement

Add Vulkan support

Better said than done, as previously mentioned on #51 the current client code heavily relies on OpenGL.

Mod management

A mod manager that would be capable of running multiple mods without conflict and also have "dependencies" so code duplication is reduced.

Have mods which can run atop of other mods
Have a launcher to select mods to run

3D models instead of flat images

[Almost] everything is a sprite right now

Unit commanding and unit construction (with HOI3 style queueing)

Client metadata (profile picture and username)

Basically the client would supply the server an image of the user along with the username, this should be required before being able to select a country.

This could be used by the server to identify and also ban/kick users.

Users can have any username they want - even duplicate usernames - provided that there isn't another user with the same name on the server we want to connect to.

Province ownership tracking is inconsistent

Province ownership can currently be deduced in several ways, most notable:

Each Province class has an std::vector<Nation*> owners member, which supposedly tracks which nations own (parts of) the province.
Each Nation class has an std::vector<Province*> provinces member, which supposedly tracks which (parts of) provinces this nation owns.

However, these two are highly inconsistent. Asking a nation which provinces it owns tends to give a list of several provinces, but checking the converse finds that most provinces claim to be unowned.

It also seems that each province has a size_t owner_id which keeps track of which nation owns it, but nation ids are stored as a uint16_t, which has a much shorter range of allowed values (for example, the default values for PROVINCE_DISPUTED and PROVINCE_NO_OWNER are both out of range for nation ids).

Map modes

Shouldn't be hard to do
Use framebuffer to draw to the div_sheet_tex

Name placement on map

Fix models

"Hover" does not seem to work for the Build screen buttons inside the Nation and Province tabs

CDCS map export

SOE will have Map export this is an issue to track that progress

Textured terrain

Textured terrain would look pretty ngl

Place window on top when pressed/moved

Lua state is never saved on the savegame, neither loaded

Have a standard endianess on networking

Right now if somehow SoE gets ported to a MIPS machine and then i try to connect to a x86 box i will surely get a lot of errors regarding endianess in the serializer.

UI for treaties & policies

Illegal instruction is produced on the server when compiling with clang

Faulting code:

nation.cpp:90

    if(pop.type_id == POP_TYPE_FARMER
    || pop.type_id == POP_TYPE_SOLDIER
    || pop.type_id == POP_TYPE_LABORER
    || pop.type_id == POP_TYPE_SLAVE) {
        return current_policy.poor_flat_tax * base_tax;
    }

Have POPs be aligned to certain ideologies (which would be a pointer, nullptr to indicate no alignment)
Each policy change would decrease/increase militancy on POPs whose views aligns most or less with those of the changed policy
A revolt due to an ideology shift resets militancy of the new ruling ideology's followers and gives them 5.0 life satisfaction and 5.0 everyday satisfacion and 5.0 luxury satisfaction to all of them, while the others have an increase, depending on how radical where the political changes
Parliament should be an insitution where aristocrats elect/reject bill propositions who aligns with their views, aristocrats with low con would accept almost any policy the player proposes, while high con aristocrats would reject, and may try to impose their own
Executive parliament is just a version of the parliament for stuff like declarations of war or treaties or building stuff and etc
State coups which basically would overthrow the goverment without a civil war and have the same effects as a won revolt
3-way or even 4-way civil wars, where the countries would have a ref_name of country_name+n, where +n is an integer that would be allocated by the server when a new party comes - when a +n postfix nation stops existing it should be removed immediately from the game - the game due to the way the engine works would treat these civil war nations as independent nations so it means they can ally with foreingers

Update to modern OpenGL

Anything higher than 2.2+ would suffice - the current client code heavily relies on GL lists and state-machine stuff that would surely cause issues when trying to port to a newer environment.

symphony-of-empires / symphony-of-empires Goto Github PK

symphony-of-empires's Issues

Recommend Projects

Recommend Topics

Recommend Org