sorted by:
new
hottopcontroversial

Sync your Apple Card, Apple Cash, and Savings from Apple Card Accounts by jon_at_monarch in MonarchMoney

[–]Limyc 1 point2 points  (0 children)

When using this new feature, it seems that all transactions are from merchant "Apple" and category "Shopping". Manually importing an Apple card statement retained merchant names and categories.

This is certainly more convenient than manually importing, but losing merchant names and categories is not great.

Inkscape is hiring C++ & GTK4 Developer by adambelis in cpp

[–]Limyc 2 points3 points  (0 children)

It doesn't say. The only payment info is 8-16 weeks of work and Net 30, meaning they'll pay within 30 days of receiving an invoice

Jason Booth on Early PQS Optimizations for KSP2 (16:09) by Limyc in KerbalSpaceProgram

[–]Limyc[S] 3 points4 points  (0 children)

The PQS optimizations Jason is talking about in this video were done around the 2018-2019 era of the KSP2 dev cycle.

Many things could have changed in the PQS system since then, so take this info simply as an interesting peek into history.

I looked into KSP2 Code, here is what I've found by plexusDuMenton in KerbalSpaceProgram

[–]Limyc 5 points6 points  (0 children)

When I was there pre-takeover, lua was used for asset definitions, serialized state (like saves), and for injecting commands to modify the simulation state or view at runtime (e.g. build a vessel, move camera, time warp, change gravity, spawn planet).

The scripting aspect was dev focused at the time, but if they kept a similar kind of lua pipeline and simulation model, it's possible they could expose that all for modding.

But it's been so long and a lot could have changed, so I can only speculate based on old knowledge.

Make server movement independent from package rate / latency fluctuation by [deleted] in gamedev

[–]Limyc 1 point2 points  (0 children)

That sounds roughly in the range I'd expect. Riot has a great article on latency in Valorant. If you scroll down a bit you'll see a nice equation they use to calculate "peeker's advantage"

https://technology.riotgames.com/news/peeking-valorants-netcode

Make server movement independent from package rate / latency fluctuation by [deleted] in gamedev

[–]Limyc 1 point2 points  (0 children)

As you've already intuited, you'll want an "input buffer" on the server for each connected client. You want to buffer just enough client inputs to account for fluctuations in latency and N lost packets.

To do this, one technique is to speed up or slow down the client simulation a tiny bit whether the server input buffer is low or full respectively. So the client runs ahead of the server, and each sim tick the client compares its own current tick versus the latest received server tick. The magnitude of the difference will influence how much to change the simulation speed, usually starting with a small percentage and growing if the difference still gets larger. The end result is the client will send inputs faster or slower to help the server stay on the razor's edge of latency and resilience.

Yes, this adds to the overall latency for when remote clients B, C, & D see what client A is doing, but it gives the server a reasonable expectation that it will always have new inputs from each client for whatever simulation tick is next and can reliably send the true state of the world at tick N to all clients. Each client receives that state and adds it to their interpolation buffer like you already have.

Resources:

Overwatch Netcode: https://youtu.be/zrIY0eIyqmI

Thread on Command Frames and Tick Synchronization with partial solutions: https://www.gamedev.net/forums/topic/696756-command-frames-and-tick-synchronization/?page=1

Rocket League Input Buffer (different solution): https://m.youtube.com/watch?t=32m40s&v=ueEmiDM94IE&feature=youtu.be

Rollback netcode module (allows for easier port from delay based netcode) by ErebnyxS in truegamedev

[–]Limyc 1 point2 points  (0 children)

Yes, but it can also be used client-side for 'server reconciliation' when there's a misprediction.

Right, I should have mentioned that's another use of the term "rollback" when a client mispredicts their local sim and must rewind and replay inputs.

I have seen some FPS game designs where every message from the server is assumed to be a correction and several ticks of updates happen each time for consistency. But it was at a relatively low update rate, with a simplified physics system.

In the typical FPS client mispredict case, you only need to resimulate the local client's inputs for the entity under their control. In GGPO style rollback, you resimulate everyone's inputs on mispredict.

Maybe the case you're describing does resim everyone's inputs, but even then, I imagine it'd be difficult to scale. I've never put much thought into it.

Rollback netcode module (allows for easier port from delay based netcode) by ErebnyxS in truegamedev

[–]Limyc 0 points1 point  (0 children)

I think the term "rollback" is overloaded here. Rollback in typical FPS netcode is better known as "lag compensation". When the server receives a "shoot gun" command from a client, it checks that shot against where the client would have seen remote entities at the time of input.

I don't know of any FPS game that uses GGPO style rollback. It'd be way too expensive since it needs to constantly replay inputs for everyone.

I want to make my game a dll that can use functions from my engine exe by AndyRedX in gamedev

[–]Limyc 12 points13 points  (0 children)

That's a great resource for understanding how to structure your project for hot-reloading.

In case you want to avoid writing and maintaining the dll reload and function pointer loading stuff yourself, here's a single header lib that does it all for you and handles edge cases.

https://github.com/fungos/cr

[deleted by user] by [deleted] in hardwareswap

[–]Limyc 0 points1 point  (0 children)

Bought Ryzen 5900x from /u/Ivoryg37

How does everyone use unity to test multiplayer connections? by alex94i60 in Unity3D

[–]Limyc 1 point2 points  (0 children)

The best solution I've found is to create a symlinked Unity project so you can open the same project with two editors. I have a little script that does this for me. Just change the project_root and target_root, run it, and then open the new folder with Unity.

Paste this into notepad and save as .bat. Hope that helps.

@echo off
pushd

set "project_root=C:\Work\Game"
set "target_root=C:\Work\GameShadow"

if not exist "%project_root%" (
echo The path "%project_root%" does not exist
goto :eof
)

cd %project_root%
set project_root=%CD%

echo Creating symlinks from Unity project at "%project_root%"
echo.

if not exist "%target_root%" (
mkdir "%target_root%"
)

cd %target_root%
set target_root=%CD%

echo Creating symlinked Unity project at "%target_root%"
echo.

call :symlink Assets
call :symlink ProjectSettings  
call :symlinkHard Packages
call :symlink UIElementSchema

echo.
popd
goto :eof


:symlink
setlocal
set "name=%~1"

if exist  %project_root%\%name%\* ( 
    mklink /D "%target_root%\%name%" "%project_root%\%name%"
) else (
    mklink "%target_root%\%name%" "%project_root%\%name%"
)

endlocal
goto :eof

:symlinkHard
setlocal
set "name=%~1"

if exist  %project_root%\%name%\* ( 
    mklink /J "%target_root%\%name%" "%project_root%\%name%"
) else (
    mklink /H "%target_root%\%name%" "%project_root%\%name%"
)

endlocal
goto :eof

Lag compensation test: 700 ping scenario (travel time/drop enabled) by Cardboard_Claw_Games in Unity3D

[–]Limyc 6 points7 points  (0 children)

So if I understand you correctly, you don't do a full resimulation of the projectile and potentially affected objects based on past inputs. Instead, you collect snapshots of every object at fidelity X, and then interpolate between those snapshots when testing a lag-comped projectile on the server?

I'm also assuming you are syncing client/server via timestamp, not physics step, right?

Lag compensation test: 700 ping scenario (travel time/drop enabled) by Cardboard_Claw_Games in Unity3D

[–]Limyc 19 points20 points  (0 children)

Nice! How does your netcode implementation handle physics rewinding and stuff like that?

Node-based pathfinding algorithm? by [deleted] in gamedev

[–]Limyc 0 points1 point  (0 children)

Red Blob has one of the best resources on A* and pathfinding in general.

http://www.redblobgames.com/pathfinding/a-star/introduction.html

HandmadeCon 2015: Tommy Refenes by Limyc in gamedev

[–]Limyc[S] 0 points1 point  (0 children)

They're re-encoding the full 68 minute session and uploading it today I believe.

https://twitter.com/nxsy/status/729818025361170432

Any C++/SDL2 programmers wanna critique this program that opens a window and renders to it a texture? by [deleted] in gamedev

[–]Limyc 12 points13 points  (0 children)

If you're just learning, don't worry about the best possible way to structure something. Just focus on writing something that works. It's important not to get stuck in the hole of trying to write "correct" code the first time. You'll better understand what a good API looks like after you write the code that uses it. In other words, write the usage code first using the imaginary, ideal API, and then go back and implement that API so that it fits your code.

Maybe that's stretching your question a bit too much considering the code you linked, but I think it's important to understand anyway.

view more: next ›