mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-19 22:44:59 +01:00
e6fa206e47e65def1acfbf53d17af55f8351ed8a
3605 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
e6fa206e47 |
Split stack 3-5c into master (switch blades, 3D sleepers, editor core, SRK stations, tutorial) (#289)
* feat(track): the rail code split by concern, the blades of the switches with the key frogs shaped from their templates The rails are laid by code of their own instead of inside Track.cpp: gauge lines (GaugeLine), knot lines (Knots.h), crossings and check rails (RailCrossings), rail materials (RailMaterials), measuring the rail profile (RailProfile), planning the cuts (RailPlan), the carving scan (RailCarve) and laying the geometry (RailLayer). A switch with the key frogs draws its blades from the tip where their planed nose ends to the heel, bent as they're thrown, and the rail behind them from the heel on, where they were laid from the start of the switch before; on a switch of the catalogue they start at the cut tip of the tables, 1.248 m from the joint at R 190, 1.5 m at R 300 (track_features::blades). The frogs cut from the rails, the wing and the check rails are built but switched off (track_features::crossings), the rails laid whole as before. The switches without the key keep the blades they had. A switch path can be a chain of pieces: pieces1 and pieces2 keep the parts of each path after the classic bezier, which stays as the approximation older versions read. A path with its radius given is a curve however gently it bends, a plain track a straight only where both of its control vectors lie along it. A vehicle trailing through a switch with a movable nose set the other way runs off the rails at it (TRAILED_SWITCH). * feat(render): the shared treads of the rails and their cut faces drawn, the cut faces in the matte variants of the rail materials Both renderers draw the treads a track shares with the rails it crosses, in the pick pass too, and a pass of their own for the faces where the rails are cut, the ends of the blades among them, in the matte variants of the rail materials, so the cut faces don't shine like the head the wheels polish. * feat(vehicle): an axle on a switch keeps to the path it came on, and coming from the frog end trails the switch through where the wheels reach the blades The switch thrown under an axle no longer moves it over onto the other path; it runs on along the one it entered. Coming from the frog end, where the blades are shaped or the frog has a movable nose, the switch set the other way is trailed through (rozprucie) only where the wheels get to the blades or to the nose, not as the axle enters the track; the other switches are trailed through as it enters, as before. * fix(track): the tracks drawn straight before, which their second control vector bends now, written to the log The simulator told a straight by the first control vector of a path alone, so a track whose second control vector bent it was drawn straight; now it's a curve. Such a track is named in the log as it loads, so a scenery made counting on the straight can be found: 25 tracks of lk357. Paths with both control vectors along them bend a centimetre or so at most and aren't named. * feat(track): 3D sleepers and switch timbers laid where the simulator makes the ballast, switched off in the build The sleepers of a track running alone are laid square to it, the timbers of the switches and crossings across the tracks running over them, shared by them, of the models set with sleepers3d and sleepers3dplain in eu07.ini; sleepers3dbed tells whether the ballast is laid under them too, lowered so they stick out of it. The layout of a cluster of tracks is worked out once and kept till a track of it changes, in a thread of its own while the simulation runs. timbermodel of a track, read and written back before, takes the place of the model of sleepers3d there. All of it is off whatever eu07.ini sets (track_features::sleepers), the tracks keeping their ballast and their sleeper models. * feat(render): the 3D sleepers and switch timbers drawn in instanced batches Render_Timbers lays the beams of the tracks in range where they're out of date and draws those of a run of tracks of a cell gathered by the model and its part or its level of detail, in as few instanced batches as they fit in; in the shadow pass only those near the camera. A track with them leaves its old sleeper model out. OpenGL 3.3 renderer only. * fix(track): the counts of what's wrong with the sleepers kept safe from the thread laying them, and that thread stopped before what it works with goes The counts of the beams clipped, dropped and off the plane, of the slowest and the biggest cluster, are counted by the thread working out the layouts in the background as well as by the simulation laying a cluster itself, and were plain values written by both; they're atomic now. What the thread keeps the clusters in, their version and the counts were made after the worker, as it first asked for them, and so destroyed before it at the exit while its thread could still be laying a cluster; they're made first now, the worker stopping and joining its thread before they go. The tracks go with the paths of the simulation, made before the worker. * revert(track): a tributary and a track of an unknown type load as before They came in with the rail code from the guards of the editor against crashing, and don't belong with the blades: a track of an unknown type loaded as a normal track of the railway could be joined to it and run on, and a tributary loaded as a river with its first path lost the second one when the editor saved the scenery. Both load as on master again; the place where the editor crashed on them is to be guarded where it is. * fix(track): the tracks drawn straight before named in the log once, as they load, and the paths of the switches with no radius told a straight as before in one term The log of the tracks the second control vector bends now was written each time the segments of a track were made again, as a track with its unevenness loads and as the editor changes or drags a track; it's written only the first time, as the track loads. The paths of a switch or a crossing with no radius keep the rule of master, a straight told by the first control vector alone, its two terms being the same length; they're one term now, with the comment saying so. * fix(track): the thread laying the sleepers stopped as the application exits, and loading no models itself The thread reads the scenery, which the application deletes as it exits well before the statics go: it's stopped and joined first thing in exit() now, the worker destroyed with the statics only where the application exits some other way, and not started again after. The models the beams are made of were loaded by the thread where it didn't find them, through the renderer, out of the thread of the renderer, into a map read by the simulation meanwhile: they're found under a lock now and loaded only by the threads other than it, again for all the tracks whenever a track changed since, before a layout is asked of it. With the 3D sleepers off in the build their settings aren't exported, and a track changed doesn't look for the tracks around to lay their beams again. * feat(track): the 3D sleepers turned on with sleepers3d in eu07.ini, no longer switched off in the build track_features::sleepers is gone: sleepers3d <model> in eu07.ini lays them, none (the default) lays nothing and the tracks keep their ballast, as before. The sleepers3d settings are written back with the others. The editor changes the tracks, so while it's open their sleepers are worked out on the main thread as they're needed, not in the background. * fix(render): only the part of a timber model drawn, not what else the model holds A timber model of parts may hold more than its begin, main and end, as the kits with the fastenings of the rails do. Those were drawn with each part of each timber, in the middle of the track; they aren't laid, so they're skipped now. * fix(track): the 3D sleepers laid only for a renderer which draws them Only the OpenGL 3.3 renderer draws the beams. With another one a track set to them lost its ballast to them, lowered or not laid at all with sleepers3dbed no, and nothing was drawn in its place. Draws_Timbers() of the renderer tells now, and where it's false the tracks keep their ballast, as with sleepers3d none. * fix(render): the submodels of a timber model left as they were after its parts are drawn They were all made visible after a part was drawn, the ones the model hides itself too, like Light_On, while the same model may stand in the scenery. The submodels of the top level besides the parts are listed as the model is loaded, hidden while a part is drawn and given back their own visibility after. The parts have to be at the top level of the model for that; a model with them deeper is logged and drawn whole. Render_Timbers no longer looks the model up under the lock for every run of tracks, the name set is enough there. * fix(render): a vertex whose faces give its texture no direction gets a tangent across its normal, not a NaN one The cut ends of the rails have one spot of the texture on all their corners, so their tangent came out of normalize() as NaN. The normal-mapped shaders then shaded them with a NaN normal: about half of the vertices of the cuts and frogs, and the end faces of the rails. * feat(track): the frogs cut from the rails turned on with frogs in eu07.ini, no longer switched off in the build frogs yes cuts the rails of the plain tracks and of the switches with the key frogs where they cross other rails, into frogs, wing rails and check rails. It's off by default: the rails are laid whole as before, the blades of the switches with the key are shaped still. * refactor(editor): the track mode file split into the files of its tools, the code as it was A pure move, so that the commits after it show what changes in each tool rather than a 4800-line file rewritten. The member functions of editor_mode go to the file the editor of this branch has them in: route, straights, lay, switchplace, switchdrive, switchtool, trackgizmo, and the rest stays in editormodetrack.cpp. The helpers of its anonymous namespace go to editormodetrackshared.h, as they were but inline, in namespace track_mode, which the files use. No line of code changes; the files add only their license, includes and the using line. * feat(editor): the groundwork the tools of the editor share - The tool interface (editortool.h), the gestures of the mouse (editorgestures.h) and what the modes share (editormodeshared.h); the projection, viewport, selection and texture picking taking them up. - Scripted input (scriptedinput): the input of a selftest script fed to the editor as if typed and clicked, the real mouse and keyboard ignored meanwhile; EU07_EDITOR_SELFTEST_HIDDEN draws into a window never shown nor focused. - The ui layers and panels of the editor, its settings, icons and the info of the includes; the layers of the scenery and their saving; the launcher mode. - utilities: user_cache_path (the cache folder of the system for the user) and the helpers of the translations. - stb_image: the gif loader takes the frame two back from the frames it decoded, not from before its buffer. - tools/editor: the scripts making the headers of the drives, the turntables, the editor and its usage. - Unit tests: test_area and the stubs of the editor the tests link. Not built on its own: the tree builds again with the selftests commit, the one before the translation. * feat(editor): the tracks laid along an alignment, to the PKP PLK norms, with their grade line and the ground - The alignment of the laying (editorAlignment, editorAlignmentStore): straights, transition curves and arcs with the cant of the norms for the speed, the radius below the minimum for it a warning; the lay, route and straights tools build on it, the route plan reading the curves going on from the tracks adjoining. - The grade line (editorProfile, the profile and gradeline tools): fitted to the terrain model or edited by hand, the tracks fitted marked in the scenery (//$f), the shared grade lines of nearly parallel tracks (//$n). - The ground under the tracks (editorGroundFollow, trackbed): the terrain drawn to the tracks and restored, the tracks put onto the terrain. - Connections between tracks (editorConnections, the connection and connection curve tools), the track presets, the shape of a track (editorTrackShape), digitizing tracks from the orthophoto, the properties sheet of the tracks (trackprops) and the track ux. - Unit tests: alignment, ground fit, heights, with the data of two fits. Not built on its own: the tree builds again with the selftests commit, the one before the translation. * feat(editor): the switches placed, slid and designed from their templates - The switch templates (editorSwitchStore, the template tool): the catalogue switches and the user's own, kept with the settings; the designer (editorSwitchDesign) with a drawing of the dimensions, a and b typed in with the shape making up the rest, a switch clicked off the orthophoto. - The curve of a switch laid into a curve (editorSwitchCurve), placement on a straight or into a curve, slide along it, crossovers and double slips (switchplace, switchslide), the drives of the switches (switchdrive) and the records of the switches placed (records). - Unit tests: test_switch_curve. Not built on its own: the tree builds again with the selftests commit, the one before the translation. * feat(editor): the tools of the infrastructure beside the tracks The gauge, speed, joints, lineside, parallel tracks, vehicles, signals, turntables, sweep and road tools with headers of their own; the kilometrage of the lines (editorKilometrage, the km tool); the infrastructure, roads and speeds behind them (editorInfra, editorRoad, editorSpeed). Not built on its own: the tree builds again with the selftests commit, the one before the translation. * feat(editor): the terrain model of geoportal.gov.pl and the orthophoto downloaded for the editor - editorNmt: the squares of the terrain model at 1 m (NMT GRID1, the WCS service of geoportal.gov.pl) fetched by two workers, kept in editor/cache/nmt/grid1 of the game folder, the heights of the scenery taken from them; the nmt mode loads it along the tracks or around the camera. - editorHttp: the HTTP client of both, WinHTTP on Windows, libcurl elsewhere where it's built with it; without it the caches only. - The orthophoto: its cache moved to the cache folder of the system for the user, the download area a polygon on the topo map (//$a) filled in the background, the 4K imagery, the tiles waiting outlined on the ground. - editorGeoMap: the topo map of the top view; heightmapterrain and the terrain streamer grow the terrain made from the model around the camera. Not built on its own: the tree builds again with the selftests commit, the one before the translation. * feat(launcher): the scenery wizard picks the place of a new scenery on the topo map the editor shares The wizard drops its own map download and decoding for the topo map widget of the editor (editorGeoMap). The place clicked becomes the geographic reference of the new scenery (//$g PUWG1992), and the scenery starts with the orthophoto of the editor on (//$o), lying under it in place. Not built on its own: the tree builds again with the selftests commit, the one before the translation. * feat(editor): the tools wired into the editor mode and the build editor_mode takes the tools of the commits before: its header declares them, editormode.cpp and the track mode drive them, and the renderers draw their overlays (opengl33 and legacy). CMakeLists lists the new sources and adds WITH_EDITOR_SELFTESTS (off by default); the unit tests build the new test files. Not built on its own: the tree builds again with the selftests commit, the one before the translation. * feat(editor): the selftests of the editor split by what they test The scripts of EU07_EDITOR_SELFTEST run the commands of editormodeselftest*.cpp: scene, track, rails, join, switch, signal, sleepers, sweep, terrain, monkey. The code is in every build; only with WITH_EDITOR_SELFTESTS=ON does the editor read the variables and run a script. The selftests of master now need the option too. The tree builds again with this commit. * feat(editor): the Polish texts of the editor, all of them in one update of editor_pl.po * fix(editor): the marks of the editor moved off the letters the starters read, and its lines told by their words The starters read some letters in a scenery file: the Starter the title //$n, the attachments //$f and the old scenery //$a, StarterNG and the launcher of the game the attachments //$f and the title //$n. The editor wrote its download area, shared grade lines and fitted tracks under them, and took every line of those marks as its own: saved, a scenery lost its title and attachments, and the starters showed the lines of the editor as them. - The download area is //$z, the shared grade lines //$w, the fitted tracks //$t. - Their lines and those of //$o are told by their first words, as //$h, //$r and //$k were: //$o only as "on 0" or "on 1", the origin or the settings of older builds after it, so a trainset described as "on ..." isn't taken. - The lines older builds wrote under //$a, //$n and //$f are read only by the words the editor wrote in them, or by its own comment line before them, under the new mark. Each save writes them again with it, also when the editor didn't change them; the lines of the starters stay. * fix(editor): a square of the terrain model cut short isn't read, and the squares are kept in the user's cache The service puts the directory of its GeoTIFF before the pixels, so a file cut short by a write or a fetch broken off was read whole, the pixels missing coming out as heights of 0 m, for good. - The reader (editorGeoTiff.hpp, with unit tests) wants all the strips the rows need, each within the file. - A square is written under a name of its own and renamed. - The squares are kept in the user's cache folder (nmt/grid1), as the orthophoto, since the game folder may not be writable; without one, in the game folder as before. The ones older builds kept there are moved over as each is asked for, a damaged one deleted. - Capabilities that didn't come aren't kept as the fallback name for the session: the next square asks again. * chore(editor): the http client said to serve the terrain model and the topo map too, the gif fix of stb_image marked local - CMake names the orthophoto, the terrain model and the topo map as what goes without libcurl. - The fix of the gif frame two back in stb_image is ours, not upstream's (v2.30 still has the old line): a comment at the line says so, for an update of stb_image to keep it. * fix(editor): the lines moved off the letters of the starters in a merged layer written once, not again with each save A merged layer's text goes into the file of its target on save, and the target is read again; the marked lines of the merged layer were dropped only for the marks the editor had changed. The lines moved to the new letters stayed with their old places, and the next save of the session wrote them into the target once more. - After a save, the marked lines of every merged layer are dropped; those of its target are read again from its file. - The lines of a dead layer aren't written again. - The selftest layermerge merges the layer of one file into another's, as the layers panel does. * feat(editor): the station as the signalling sees it, found from a switch of it, and its schematic editorStation: the switches joined by plain track no longer than 1.5 km, the tracks between them and the lines leading out, 400 m of each beyond the outermost switch; laid out as a schematic along the main track through the station. The track circuits, the signals and their lights, the lengths of the station tracks and the lines to the next stations are worked out from it for the signalling tool. Nothing uses it yet: the signalling tool, wired in the next commit, does. It builds on its own. * feat(editor): the signalling of a station in the Signalling tab, laid out from a switch of it as on the lines of PKP PLK LMB on a switch in the Signalling tab opens its station: the schematic in a window of its own, the name, the code, the line and the km of the station, and the steps of its signalling, each one step of undo: - the switches numbered along the station after its code, bpd_1, the parts of a slip bpd_15a..d; the drives and the objects naming a switch follow it, events written by hand keep the old names; - the tracks cut at the joints of the track circuits, Ie-4, and the circuits named, bpd_iz1, bpd_it1; - the entry, exit and shunting signals placed and named, A, F1, Tm1, from the templates chosen; - the signals of the lines out: the automatic block of three or four aspects, the block sections no shorter than the braking distance, or the semi-automatic one with a warning disc; block boundaries drawn by hand; - the lights each signal needs for its routes, Ie-1 and Ie-4 § 8, its template fitted to them; - the SHP track resonators the signals lack, rezonator.inc; - the lengths of the station tracks as a table, and what the station and its lines still lack, with Repair. The stations described are kept as //$s lines in the files of their layers. * fix(editor): the signals of a station and of its lines not placed with no template for a kind, no track cut for them first - Set the signals and Set the line signals cut the tracks first, and only then found no template for a kind. They stopped there, but the cuts stayed as a step of undo. Now they ask for the templates first, by the lookup signal_batch() uses (signal_template_for(), behind editor_signals::signal_templates_missing()). Without one nothing is cut. - Set the signals and Set the track circuits again under Track lengths had the ids of the buttons of the steps above them. ImGui flagged them when hovered. Each now has an id of its own. * fix(utilities): win1250_to_utf8 turns the polish letters into utf-8, not into themselves utilities.cpp starts with a byte order mark, so the compiler reads it as utf-8. The game's targets don't get /utf-8, though: set_target_properties(... COMPILE_OPTIONS ...) in the MSVC block of CMakeLists.txt replaces the options add_compile_options gave them. So the string literals went into the program in the code page of the system, windows-1250 on a polish one, and the map of win1250_to_utf8 turned each letter into itself. What read windows-1250 through it got no utf-8: the names, descriptions and categories of the sceneries and the names of the textures in the launcher, and the descriptions of the templates in the editor. The editor writes such a description back through utf8_to_win1250, which makes a question mark of each byte that doesn't start a utf-8 sequence, so the letters it had read unchanged didn't come back. The utf-8 sequences are written as bytes now, the way utf8_to_win1250 has them, so they don't depend on the options. The options stay as they are: with /utf-8 other literals of the files with a byte order mark would change, the "±" of the table of Bezogonkow would take two bytes and move the letters after it. The unit tests check the letters and that the text given is valid utf-8. (cherry picked from commit |
||
| 34991dbe11 | apt timeout and retry (#329) | |||
|
|
80eceaa182 |
Merge pull request #313 from miloszunio/pr/perspective-pan
feat(editor): the wheel held and dragged pans the perspective view too, the ground under the cursor going along with it |
||
|
|
eeb2c67d02 |
Merge pull request #327 from miloszunio/pr/mouse-hit
fix(render): Mouse_Hit() no longer says yes when it doesn't know |
||
|
|
6fbd4082ed |
Merge pull request #310 from miloszunio/pr/road-points-under-terrain
feat(editor): the points of the roads picked on the screen, also under the terrain; Alt+drag their height |
||
|
|
5756413590 |
Merge pull request #282 from MaSzyna-EU07/fix/freight-brake-setting-cw1
AI wagon inspector: brake settings G/P/R by the instruction Cw-1 (eu07/maszyna#350) |
||
|
|
afc7fc4218 |
Merge pull request #283 from MaSzyna-EU07/feat/persistent-odometer-store
Persistent odometer for all speedometers (#72) |
||
|
|
9aa0ae4efa |
Merge pull request #324 from MaSzyna-EU07/fix/ci-cancel-superseded-builds
CI: cancel the builds of a commit superseded by a newer push |
||
|
|
8b730b889b |
fix(render): Mouse_Hit() no longer says yes when it doesn't know
The base renderer answered true, so the legacy OpenGL renderer and any other one without its own answer told the editor the cursor was over something even over the sky, with a stale Mouse_Position(). The base answers false now; the legacy renderer answers from the depth it reads under the cursor, as the gl33 one does (the gl46 and Vulkan ones of feat/gl46-migration do already). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ |
||
|
|
b8b6b3aa76 |
fix(editor): a road point picked on the screen only when nothing is under the cursor, and not through it; Alt+drag dropped with Esc, the work area or the window, no undo in the middle of it
The click takes the point by the ground clicked, then the piece or the junction under the cursor; the point nearest on the screen only when there's none, no farther than what is under the cursor and a bit beyond it, by whole pixels first and the range then, so the order of the roads doesn't decide. The ends of the pieces are gone through without looking for the repeated ones (editor_road::each_joint), joints() isn't needed. Esc, the road window closed, another tool or the track work area drop the drag; Ctrl+Z and Ctrl+Y wait for its end. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ |
||
|
|
bd1d65cf15 |
fix(editor): no pan of the perspective view started on the sky, where the depth keeps the last hit
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ |
||
|
|
10c7527a64 |
AI: reduced signal speed ends at a marked end of the interlocking area (SignalAreaEnd) (#305)
* feat(ai): reduced signal speed ends at a marked end of the interlocking area Ie-1 (from 17.01.2026, signals on colour light signals, par. 8): a reduced speed shown by a signal (S10 "40, then Vmax" and the like) holds to the end of the interlocking area the signal guards. Only on secondary main tracks does it hold for the whole route, and on semaphore signals (Sr3) at an entry or route signal 40 holds for the whole route as well. The AI kept the speed of the passed signal (VelSignalLast) until it passed the next signal, or until no signal, switch or W4 was left in the scan. On a station the exit signal, the far switches and the W4 are always in the scan, so after S10 at the entry signal onto the principal main track the AI ran 40 all the way to the exit signal. A scenery can now mark where the interlocking area ends, with a putvalues event read by the scan like a signal: event <name> putvalues 0 none x y z SignalAreaEnd 0 0 endevent attached to event1/event2 of the track (the direction the train runs), past the last switch of the area, on the principal main track only. In train mode the reduced speed of the passed signal ends once the rear of the train is past the marker, i.e. the whole train has left the switches. A signal at stop passed (speed 0) is not lifted. The marker sends no command and is not treated as a signal or a speed limit: it does not end the restricted run on sight after S1 on automatic block, and it means nothing in shunting. The driver hint for the end of the speed limit uses the marker when there is one instead of the farthest switch in the scan. Where the marker is left out (secondary main tracks, stations with semaphore signals, every existing scenery) the speed holds as before. Game data: nothing has to change in the SVN for this to work. Sceneries may add the marker; a release without this change does not read SignalAreaEnd (an unknown putvalues command is not scanned), so it ignores it. * fix(ai): a marker behind the last passed signal does not end its speed The marker acted on whatever speed the last passed signal had left when the rear of the train passed it. A train longer than the way from the marker to the next signal, or one which started standing over the marker (scenario start at a platform, a direction change), had its head past the next signal before its rear was past the marker of the previous area, and the marker then lifted the 40 of the new signal while the head ran through its switches. Passing a signal now drops the markers that lie before it in the scan table: they end the area of an earlier signal. In shunting the marker is no longer thrown away when the rear passes it, so a train order given before the next signal still finds it. A note to the previous commit: a release without SignalAreaEnd does not scan the marker, it runs it as an ordinary putvalues event when a vehicle passes, which logs it and sends the mover a command it does not know, to no effect. * AI: a higher road speed (W27/W27a) takes effect once the rear is past the sign (#306) * fix(ai): a higher road speed (W27) holds only once the rear is past the sign The road speed of a RoadVelocity event (W27/W27a) took effect as soon as the head of the train passed the sign, both a lower and a higher one, and the entry left the scan table in the same pass. A lower speed from the head is right: the AI brakes before the sign, it is in the scan. A higher one let the AI speed up while the rest of the train was still on the stretch of the lower speed. Now a higher road speed (compared through min_speed, so -1 is no limit) holds once the whole train is past the sign. Until then the entry stays in the table and is left out of the rest of the table update, which would have dropped it. What the update did to a passed passive event when it dropped it (command, VelSignal, the end of the restricted run on sight) now happens when the rear passes the sign instead of the head. One-way signs and 2w27 stay as they were: the scan reads only the event of the running direction. The comments of the road speed and section speed branches named them W6 and W27; they are W27/W27a and W9. * fix(ai): road speed of cars from the head, W27 does not end the run on sight Two faults of the previous commit, found in review: A car's passed events leave the scan table at the latest when its rear passes them (TableCheck), before the table update could see the rear past the sign, so an AI car never took a higher road speed and kept the lowest one for good. A car takes the road speed from the head again, as before. With the sign now kept in the table until the rear passes it, the generic handling of a passed passive event ran only then, and it ends the run on sight after S1 on automatic block. A train which stopped at S1 with its rear not yet past a W27 lying shortly before the signal would, once on the move, end the run on sight and run into the occupied block at road speed. A road speed sign is no signal: it no longer ends the run on sight at all, which also ends the same thing happening, before this branch, to a train whose head passed a W27 while running on sight. * fix(ai): a passed road speed sign is handled when the head passes it, as before The previous commit left a road speed sign out of the table update until the rear passed it, so the generic handling of a passed passive event (the SetVelocity command, VelSignal, the end of the run on sight) ran up to one train length later than before. By then the order may have changed: a train standing over a W27 at its last station, with Shunt as its next order, would be switched back to Obey_train by that command once its rear passed the sign on the next forward move. Now the sign is handled as before in the first pass after the head passes it. In place of dropping it from the table it is then marked as held (spRoadVelHeld) and only waits for the rear, left out of the rest of the update. So everything but the moment a higher road speed takes effect is as it was, and the change of the previous commit that kept a W27 from ending the run on sight is undone: it is not needed any more. A car is told by CategoryFlag == 2, the same test TableCheck drops its passed events by, so a unimog (rail and road) holds the sign for its rear like a train. * fix(ai): a road speed released by the rear doesn't exceed a lower sign after it the head has passed A train longer than the distance between two road speed signs, as W27a 120 and then W27a 60, passes the 60 with its head before its rear is past the 120. Releasing the 120 then set the road speed to 120, and only the held 60 handled later in the same table pass brought it back down, so the result depended on the order of the table and on the loop reaching that entry (it stops at the first point that orders a stop). When the rear passes a sign, the road speed is now the lowest of that sign and of the signs after it that the head has passed and the rear not yet. Without such a sign it is set as before. * fix(ai): a passed road speed sign not yet marked as held caps the released one too The sign after the released one may have been passed by the head in the very tick the rear passes the released one, before the table update marks it as held. It is now taken into the lowest speed as well (an enabled road speed entry behind the head), so the result doesn't depend on the table update reaching it in that tick. --------- Co-authored-by: maj00r <maj00r@host> --------- Co-authored-by: maj00r <maj00r@host> Co-authored-by: jerrrrycho <jurek.pakula@gmail.com> |
||
|
|
c2db969bd1 | ci: point from the linux job to the note on the concurrency groups build-fix-ci-cancel-superseded-builds | ||
|
|
963791e3f3 |
ci: cancel the builds of a commit superseded by a newer push
A push to a pull request or to a branch started new runs of the Build and Build binaries workflows while the runs for the older commit went on to the end, holding the runners for results nobody needs. The Build workflow now has a concurrency group per pull request, and the build jobs of Build binaries one per branch or pull request, with cancel-in-progress: the run for the older commit is cancelled when a newer one starts. Pushes to master get a group of their own (the commit), so the runs on master are neither cancelled nor held back by one another. In Build binaries the groups are on the build jobs, not on the workflow, so a publish job already running is left to finish. sonar.yml needs no change: it already posts an error status (analysis skipped) on the commit of a cancelled Build run, and the newer commit gets its own pending status and analysis. |
||
|
|
5a45446b4a |
fix: record the odometer of a vehicle whose cab shows it, also without a driver's brake valve
HasDriverCab() decides by the BrakeHandle, which the DL2 draisine doesn't have: its cab counter (distcounter: with offset 85) was never saved and started from the .mmd offset each session. A vehicle is now also recorded when a cab showed its odometer in the session (reading::shown: TTrain loaded a cab model of it for a player, or bound a cab's counter to it) or when a cab's counter seeded its state (origin::counter). The counter-seeded state is saved as a known one, so the next session starts from it and keeps counting whenever the counter is bound again.build-feat-persistent-odometer-store |
||
|
|
9a873b2e18 |
Merge remote-tracking branch 'origin/master' into feat/persistent-odometer-store
# Conflicts: # vehicle/DynObj.h |
||
|
|
9043d2d5fc |
fix(ai): a brake cut-out skipped on the run is done once the train stands
A train formed by coupling is inspected at the first buffer contact, above the speed the inspector takes for a standstill, so its wagons without G kept their brakes (Cw-1 §19.9) until some later stop, if any. brake_setting::apply() now tells when it left a cut-out because the train was moving; AutoRewident keeps that as a pending re-inspection and TController::reinspect_brakes() runs it again once the train is below EU07_AI_MOVEMENT. The flag is dropped when the order stops being a train run. The legacy inspector (ai.brakesetting.cw1 no) never cuts a brake out and is unchanged.build-fix-freight-brake-setting-cw1 |
||
|
|
a1335c1586 |
Merge remote-tracking branch 'origin/master' into fix/freight-brake-setting-cw1
# Conflicts: # utilities/Globals.cpp |
||
|
|
5bac4e1cf1 |
Fix the four issues failing the Sonar quality gate on master (#323)
* fix(scripting): forward the object in push_object of the Lua screens (cpp:S5417) push_object takes a forwarding reference and called std::move on it, which SonarCloud reports as a blocker bug. It only worked because every caller passes an rvalue: with an lvalue Type_ is deduced as a reference, and new Type_(std::move(Object)) doesn't even compile. The object is now forwarded, and the userdata is sized and built for std::remove_cvref_t<Type_>, the type collect<> and check_object<> are used with: an rvalue is moved in, an lvalue would be copied. Every caller passes an rvalue of lua_image, bitmap_font or glyph, so they move the object in exactly as before. * fix(simulation): turbidity from the overcast without branches of the same value (cpp:S3923) The chain of conditionals setting Global.fTurbidity had pairs of branches with the same result (<= 0.10 and <= 0.20 both 4, and so on, the last two both 9), which SonarCloud reports as a bug. The thresholds that changed nothing are gone and the mapping is a small function: up to 0.20 gives 4, up to 0.40 5, up to 0.60 6, up to 0.70 7, up to 0.80 8, anything else 9. The comparisons are the same ones, in the same order, so every overcast value gives the turbidity it gave before. * test: script screen tests keep their files in the build folder, not in the temporary one (cpp:S5443) The folders of the script screen host tests were made in the system's temporary directory, and the sandbox test put its "outside.txt" straight into that directory. SonarCloud reports both uses as vulnerabilities: the directory is writable by everyone. The folders are now made in the build folder of the unit tests, passed to them as EU07_UNIT_TESTS_SCRATCH, the way EU07_UNIT_TESTS_DATA is. The scripts are one level down in the folder of a test, so the file the sandbox test puts outside the folder of the scripts is still inside the folder of the test and goes with it. Nothing depends on the working directory, and nothing is left behind. |
||
|
|
b251b6fe42 |
feat(blackbox): a black box of the session: the run, the cab, the signals and the stations to a file (#322)
* feat(blackbox): a recorder of the run, the cab, the signals and the stations to a file With the physics logs on (and the new eu07.ini setting blackbox, on by default), the simulator writes a black box of the session to physicslog/*.blackbox: the scenery map (tracks, signals, W4 stop points with their heading, W6 horn points), the timetables of the user's train, and at 10 Hz the cab of the vehicle the user sits in (speed, controllers, brakes, pressures, lights with the pattern the run asks for, the movement kind), the AI's reference for the same place (target speed, next limit, braking distance), the consist, the cameras and the vehicles around. Changes go in as they happen: switches, signal aspects, commands, signals passed with their aspect, stations stopped at, passed or missed, horn requests, the autopilot switched on or off, couplings and vehicles removed. The driving aid's next speed limit moved from the UI panel to TController::next_speed_limit(), so the panel and the recorder read the same. The format is described in blackbox_doc.md; the writer and the reader of the records have unit tests. * fix(blackbox): the aspect a signal had when passed, the lamps the ends have, vehicles taken off - A passed signal is written with the aspect the train had of it, kept in the speed table, not the one its memory cell shows when the pass is noticed: by then the train itself on the track behind has often set it to stop, and most passes were written as at stop. - The cab record gains the lamps the vehicles at the head and the tail have at their outer ends (136 bytes), so a reader can check the light pattern against them as the driver does (no upper headlight, the auxiliary lamps, the rear-end signals only). - A vehicle taken off the scenery and still pointed at by a coupler or the camera gets no new number; the camera lets go of it. - The timetable written before a station goes under the vehicle the user is in now, not the one of the last look. - The file buffer is given once the file is open: MSVC passed over one given before. - The doc tells the AI fields before the consist is started and when entering a vehicle is a driver change. * fix(blackbox): the stop of an automatic block signal passed is written as a stop The speed table keeps the stop of an automatic block signal (SetVelocity 0 x) as the speed allowed after it, with spStopOnSBL; a pass of it was written as that speed with no flag. It is written as 0 with the flag of an automatic block stop again. * feat(blackbox): the doors, the brakes of the whole train, a diesel's engine and the rest of the cab The cab record grows from 136 to 190 bytes, so that a reader can check everything the driver did: - the doors: the permits on each side, the departure signal, the steps, the door lock and whether the doors are locked; - the brakes: the equalizing reservoir of the driver's valve, the main reservoir pipe, the highest brake cylinder pressure of the train, the hand brake, the releaser, the setting (G/P/R/Mg) and the mode (PS/PN/EP/MED); - what drives the vehicle (electric, induction, diesel, diesel-electric, steam, none), its power, a diesel's oil pressure, water, oil and engine temperatures, overheating, fuel and oil pumps, clutch and torque converter, the motor fans; - the cruise control and its speed, the integrated driving handle of a unit, the radio channel, the horn's tones. New device bits use the upper half of the 32-bit field; the new fields come at the end of the record, so older readers still read it. * fix(blackbox): the driver's valve field is what its gauge shows, the radio channel has no none Handle->GetCP() is the equalizing reservoir of most valves but the time reservoir of the FV4a, empty but after an overcharge: the field is named and documented as what the valve shows. With no driver the radio channel reads as the first one, not 0. --------- Co-authored-by: maj00r <maj00r@host> |
||
|
|
18c56359ee |
fix(ai): the stop point on a W4 kept the margin of a passenger stop from the platform's end (#321)
The W4 stop point was shifted with fMinProximityDist (8 m), while the train comes to a stand anywhere up to the margin of a passenger stop (10-15 m by the number of vehicles) short of it. A train stopping by the middle of a platform could so stand with its tail a few metres past the platform's end (L053: Swoszowice 204.5 m of 201, Tumlin 244.3 m of 242). The point is now shifted with the same margin the stop is judged by, so the tail stays inside (197.5 m and 240.4 m on the same run). Co-authored-by: maj00r <maj00r@host> |
||
| 5764e942a7 | build(linux): load the shared libraries from the game folder and ship them in the build (#320) | |||
| 226155d430 | feat(physics): physical coupler model for the player's train and those it closes in on, plastic hit on solid buffers | |||
| aba8687678 | feat(ui): repair the broken coupler next to the camera from the driving aid | |||
| 8e97277bcb | feat(debug): coupler section in the debug panel, with the parameters of the physical model | |||
| c85aab4f3f | feat(physics): physical coupler model with slack, hysteresis and breaking | |||
| 39e855d3a5 |
Merge pull request #319 from MaSzyna-EU07/docs/agents-md
docs: AGENTS.md as the one set of rules for every coding agent |
|||
| b42d2f7b66 | docs: AGENTS.md as the one set of rules for every coding agent build-docs-agents-md | |||
| b3e6e02779 | ci(windows): build lua51.dll for the unit tests | |||
|
|
5c8cc6d9a5 |
feat(ai): PointVelocity, a speed limit for the head of the train at a point beyond the cell (#304)
* feat(ai): PointVelocity, a speed limit for the head of the train at a point beyond the cell A memory cell (or putvalues) with "PointVelocity v d" tells the train that the head has to be at v km/h at the point d metres beyond the cell (v -1: no limit). The cell is read by the speed table scan like a signal, live until the head passes it; what it says then is kept for the point, later changes of the cell don't concern that train. The limit ends when the head passes the point, it doesn't hold the rest of the train and doesn't extend or break a speed limit of the line, like W27 of length 0 moved d metres on. The AI brakes so the head reaches the point at v; for a human driver it only shows as the next speed limit of the driving aid, the security systems don't see it. It is made for the warning disc of a level crossing (TOP, Osp1/Osp2), which has to give 20 km/h at the crossing about 500 m beyond the disc, as the disc showed when the train passed it. The cell with PointVelocity as its first command makes its getvalues scanned (passive) as SetVelocity does; PutCommand ignores it when such an event runs. Old commands keep working as they did, SetProximityVelocity included. * fix(ai): a point limit isn't a signal, and a PointVelocity 0 can be released From the review of the PointVelocity commit: - a cell rewritten from SetVelocity or ShuntVelocity to PointVelocity drops the flags of a signal, so it can't count as a semaphor or report a signal passed at danger; - PointVelocity 0 is read on after the head passes the cell, as a stop of a signal is, otherwise the train would stand short of the point for good; - a point limit doesn't become eSignNext, so a W4 between the disc and the crossing keeps its release. * fix(ai): a PointVelocity limit outlives a rebuilt speed table, and holds when shunting The state of the cell, latched when the head passes it, is now kept by the controller apart from the speed table, and the distance to the point is measured by the movement of the consist in the world. Stopping, backing up and going on between the cell and the point, coupling or a takeover no longer lose the limit or read the cell anew, unless the head backs up past the cell, when the cell is read again. Near the point the desired speed is capped to the limit, so a train that coasts within its tolerance (as a shunting one does) reaches the point at it. * fix(ai): review of the latched point limits - a point the head has passed already isn't latched, and a latched limit at or behind the head isn't applied (it asked for a full brake for a cycle); - a latched limit is dropped once the head backs up behind its cell, so it can't follow the consist onto another track; the table reads the cell again; - a cell latched already, found under the consist by a rebuilt table, is ignored whatever it shows now (a 0 for the next train no longer stops it); - PointVelocity 0 stops at the usual distance, not from the approach; - the heading follows the track under the measured vehicle, not the chord of the consist, which a long consist on a tight curve holds far off the track; - vehicles coupled or uncoupled at the end towards the point move the head; - a jump of the consist (moved elsewhere) drops the latched limits. * fix(ai): a cab change and curves don't move the latched point limits - the end of the consist towards the point is taken into the distance only when the consist changes (its end vehicles or its length), not when another vehicle is measured from (a cab change at a reversal) nor when a curve shortens its projection; - the way of travel follows the direction of the driver's vehicle against its own couplers, not the chord of the consist, which on a balloon loop points against it. * fix(ai): a coupling with a cab change in one order still moves the head of a latched point limit The end of the consist measured from the previous vehicle is moved to the place of the new one, so a coupling or an uncoupling followed at once by a change of direction to the other cab (the shunting orders) is taken into the distance to the point. --------- Co-authored-by: maj00r <maj00r@host> |
||
| ee6f9a0aa2 | Merge branch 'master' of https://github.com/MaSzyna-EU07/maszyna into feat/wasm-screens | |||
| e433b43fef | Script screens: led_post and resize of the Lua screens on the gpu | |||
| c4924f756d | Lua script screens beside the WebAssembly ones | |||
| a73585dca0 | Dont copy entire python env when already present | |||
| 18c333b089 | wasm display support | |||
| c9792672c6 | fix(render): textures of a far vehicle no longer come back black with gfx.resource.move (#308) | |||
|
|
fabbfdc782 |
feat(editor): the wheel held and dragged pans the perspective view too, the ground under the cursor going along with it
Pressing the mouse wheel and dragging pans the top view; now it pans the perspective view as well. The camera moves over the ground, its height and its turn kept, by as much of the ground as the cursor crosses where it was pressed: metres to a pixel taken from the distance to what is under the cursor, and a pixel up the screen counted as more of the ground than one across as the camera looks down less steeply. With nothing under the cursor (the sky) it doesn't start. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ |
||
|
|
6684baefc3 |
feat(editor): the points of the roads picked on the screen, also under the terrain; Alt+drag their height
The points where the pieces of a road meet were picked only by the ground clicked: one more than 3 m above or below the ground under the cursor (a road taken down into a cutting, under an embankment) couldn't be picked again. Now the point nearest to the cursor on the screen (within 12 px, the one nearer to the camera of those about as near) is picked first, the ground as before after it. Alt+LMB on a point and dragging up or down changes the height of the selected points (Ctrl: ten times finer); the change shows as yellow lines and a label by the cursor while dragging, and is applied, as one step of the history, when the button is let go. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ |
||
|
|
685258d787 |
Merge pull request #274 from MaSzyna-EU07/feat/elf-master-controller-emergency-brake
Elf: emergency brake position in the master controller (eu07/maszyna#413) |
||
|
|
dfb2329fb5 |
Merge remote-tracking branch 'origin/master' into feat/persistent-odometer-store
# Conflicts: # vehicle/Train.cpp |
||
|
|
8809ce3162 | Merge remote-tracking branch 'origin/master' into fix/freight-brake-setting-cw1 | ||
|
|
12299bb1fa | Merge remote-tracking branch 'origin/master' into feat/elf-master-controller-emergency-brake | ||
|
|
b256c3efa9 |
refactor: MOVER.h includes the odometer's plain data only
odometer::reading moves to vehicle/odometerreading.h, the store with its files stays in vehicle/odometer.h, so the physics header doesn't pull in the filesystem and the streams |
||
|
|
8029740770 |
fix: read the odometer files of the koliber screens too, say why the unit renderers' drop a letter
the renderers of the units (elf_v1, impuls_v1) keep the unit's state, their cars are named after the unit and the letter of the car (EN76-022a .. EN76-022d), so they drop the last character. the koliber screens of scripts/ keep theirs in scripts/kilometry by the whole name, which wasn't read |
||
| 1760c90934 |
Merge pull request #271 from MaSzyna-EU07/feat/diesel-throttle-position-marker
Throttle position marker for diesel locomotives (#74) |
|||
|
|
6f1055e09d |
fix: a duplicated cab control keeps its scale table
MirrorCopy() of a duplicate: yes control (#285) now copies the scaletable: of the duplicate's definition too, so the copy is animated on the same non-uniform scale.build-feat-diesel-throttle-position-marker |
||
|
|
ee42a80188 | docs: the odometer store is keyed by the vehicle's name in the scenario | ||
|
|
acf0716a9c |
fix: keep the odometers of the vehicles with a driver's cab only
every vehicle which ran got a line in the store, the wagons of the AI's trains in every scenario too. the store records a vehicle with a driver's brake valve (BrakeHandle in the .fiz), which can show its odometer; the locomotives and units the AI runs before a player's cab loads them still get in with their replaceable made up states. the states already in the file stay as they are |
||
|
|
478727850d |
Merge remote-tracking branch 'origin/master' into feat/diesel-throttle-position-marker
# Conflicts: # vehicle/Gauge.h # vehicle/Train.cpp |
||
|
|
729f15e878 |
fix: a test run neither reads nor saves the player's odometer store
the autotests (--test, Global.test.enabled) run the vehicles of the player's game: their odometers count from the legacy or made up states in a store of their own, and nothing is written to eu07_odometers.txt |