jackcartersmith/gse
1
0
Fork 0
Code Issues Pull Requests Actions Releases Activity

Compare commits

base: jackcartersmith:dev
Branches Tags
jackcartersmith:dev
jackcartersmith:third-party/build/win
jackcartersmith:third-party/deps/win
jackcartersmith:third-party/deps/linux
jackcartersmith:third-party/deps/common
jackcartersmith:third-party/common/win
jackcartersmith:third-party/common/linux
jackcartersmith:third-party/build/linux
jackcartersmith:2024_10_21
jackcartersmith:2024_10_14
jackcartersmith:2024_10_07-overlay_fix_test_03
jackcartersmith:2024_10_07-overlay_fix_test_02
jackcartersmith:2024_10_07-overlay_fix_test_01
jackcartersmith:2024_10_07
jackcartersmith:2024_09_27
jackcartersmith:2024_8_25
jackcartersmith:2024_8_19
jackcartersmith:2024_8_4
..
compare: jackcartersmith:2024_8_19
Branches Tags
jackcartersmith:dev
jackcartersmith:third-party/build/win
jackcartersmith:third-party/deps/win
jackcartersmith:third-party/deps/linux
jackcartersmith:third-party/deps/common
jackcartersmith:third-party/common/win
jackcartersmith:third-party/common/linux
jackcartersmith:third-party/build/linux
jackcartersmith:2024_10_21
jackcartersmith:2024_10_14
jackcartersmith:2024_10_07-overlay_fix_test_03
jackcartersmith:2024_10_07-overlay_fix_test_02
jackcartersmith:2024_10_07-overlay_fix_test_01
jackcartersmith:2024_10_07
jackcartersmith:2024_09_27
jackcartersmith:2024_8_25
jackcartersmith:2024_8_19
jackcartersmith:2024_8_4

No commits in common. "dev" and "2024_8_19" have entirely different histories.
dev ... 2024_8_19

189 changed files with 2538 additions and 5503 deletions
Show Stats Expand all files Collapse all files

20
.editorconfig
View File

@ -1,20 +0,0 @@
root = true
[*]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
max_line_length = 120
[*.py]
indent_size = 4
[*.h]
indent_size = 4
[*.cpp]
indent_size = 4

106
.github/workflows/emu-build-all-linux.yml vendored
View File

@ -1,4 +1,4 @@
name: "Build emu (Linux)"
name: Build emu (Linux)
on:
workflow_call:
@ -7,26 +7,26 @@ on:
# allows manual trigger
permissions:
contents: "write"
contents: write
env:
PREMAKE_ACTION: "gmake2"
DEPS_CACHE_KEY: "emu-deps-linux"
DEPS_CACHE_DIR: "build/deps/linux"
PREMAKE_ACTION: gmake2
DEPS_CACHE_KEY: emu-deps-linux
DEPS_CACHE_DIR: build/deps/linux
PACKAGE_BASE_DIR: "build/package/linux"
THIRD_PARTY_BASE_DIR: "third-party"
THIRD_PARTY_BASE_DIR: 'third-party'
jobs:
deps:
name: "Restore or build deps"
name: Restore or build deps
if: ${{ !cancelled() }}
uses: "./.github/workflows/emu-deps-linux.yml"
uses: ./.github/workflows/emu-deps-linux.yml
builds-matrix-linux:
name: "build"
needs: ["deps"]
runs-on: "ubuntu-20.04"
name: build
needs: [ deps ]
runs-on: ubuntu-24.04
if: ${{ !cancelled() }}
continue-on-error: true
@ -34,63 +34,61 @@ jobs:
fail-fast: false
matrix:
prj: [
# regular api
"api_regular",
"steamclient_regular",
# api + client (experimental)
"api_experimental",
"steamclient_experimental",
# tools
"tool_lobby_connect",
"tool_generate_interfaces",
]
arch: ["x64", "x32"]
cfg: ["debug", "release"]
# regular api
'api_regular', 'steamclient_regular',
# api + client (experimental)
'api_experimental', 'steamclient_experimental',
# tools
'tool_lobby_connect', 'tool_generate_interfaces',
]
arch: [ 'x64', 'x32', ]
cfg: [ 'debug', 'release', ]
steps:
# clone branch
- name: "Checkout branch"
### clone branch
- name: Checkout branch
uses: actions/checkout@v4
# deps
- name: "Restore deps"
id: "emu-deps-cache-step"
### deps
- name: Restore deps
id: emu-deps-cache-step
uses: actions/cache@v4
with:
key: "${{ env.DEPS_CACHE_KEY }}-${{ env.PREMAKE_ACTION }}"
path: "${{ env.DEPS_CACHE_DIR }}/${{ env.PREMAKE_ACTION }}"
key: ${{ env.DEPS_CACHE_KEY }}-${{ env.PREMAKE_ACTION }}
path: ${{ env.DEPS_CACHE_DIR }}/${{ env.PREMAKE_ACTION }}
# extra helpers/tools, these are not built inside the deps build dir
- name: "Clone third-party build helpers (common/linux)"
## extra helpers/tools, these are not built inside the deps build dir
- name: Clone third-party build helpers (common/linux)
uses: actions/checkout@v4
with:
ref: "third-party/common/linux"
ref: 'third-party/common/linux'
path: "${{env.THIRD_PARTY_BASE_DIR}}/common/linux"
- name: "Clone third-party build helpers (build/linux)"
- name: Clone third-party build helpers (build/linux)
uses: actions/checkout@v4
with:
ref: "third-party/build/linux"
ref: 'third-party/build/linux'
path: "${{env.THIRD_PARTY_BASE_DIR}}/build/linux"
# fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: "Give all permissions to repo folder"
shell: "bash"
working-directory: "${{ github.workspace }}"
### fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: Give all permissions to repo folder
shell: bash
working-directory: ${{ github.workspace }}
run: sudo chmod -R 777 "${{ github.workspace }}"
# generate project files
- name: "Generate project files"
shell: "bash"
working-directory: "${{ github.workspace }}"
### generate project files
- name: Generate project files
shell: bash
working-directory: ${{ github.workspace }}
run: |
sudo chmod 777 ./${{env.THIRD_PARTY_BASE_DIR}}/common/linux/premake/premake5
./${{env.THIRD_PARTY_BASE_DIR}}/common/linux/premake/premake5 --file=premake5.lua --genproto --emubuild=${{ github.sha }} --os=linux gmake2
# mandatory Linux packages
- name: "Install required packages"
shell: "bash"
## mandatory Linux packages
- name: Install required packages
shell: bash
run: |
sudo apt update -y
sudo apt install -y coreutils # echo, printf, etc...
@ -102,22 +100,22 @@ jobs:
sudo apt install -y libgl-dev # needed for overlay build (header files such as GL/gl.h)
# sudo apt install -y binutils # (optional) contains the tool 'readelf' mainly, and other usefull binary stuff
# build target
- name: "Build target"
shell: "bash"
working-directory: "${{ github.workspace }}/build/project/gmake2/linux"
### build target
- name: Build target
shell: bash
working-directory: ${{ github.workspace }}/build/project/gmake2/linux
run: |
echo "dry run..."
make -n -j 2 config=${{ matrix.cfg }}_${{ matrix.arch }} ${{ matrix.prj }}
echo "actual run..."
make -j 2 config=${{ matrix.cfg }}_${{ matrix.arch }} ${{ matrix.prj }}
# upload artifact/package to github Actions
- name: "Upload target package"
### upload artifact/package to github Actions
- name: Upload target package
uses: actions/upload-artifact@v4
with:
name: "emu-linux-${{ matrix.prj }}-${{ matrix.cfg }}-${{ matrix.arch }}-${{ github.sha }}"
path: "build/linux"
if-no-files-found: "error"
if-no-files-found: 'error'
compression-level: 9
retention-days: 1

108
.github/workflows/emu-build-all-win.yml vendored
View File

@ -1,4 +1,4 @@
name: "Build emu (Windows)"
name: Build emu (Windows)
on:
workflow_call:
@ -7,25 +7,25 @@ on:
# allows manual trigger
permissions:
contents: "write"
contents: write
env:
PREMAKE_ACTION: "vs2022"
DEPS_CACHE_KEY: "emu-deps-win"
DEPS_CACHE_DIR: "build/deps/win"
PREMAKE_ACTION: vs2022
DEPS_CACHE_KEY: emu-deps-win
DEPS_CACHE_DIR: build/deps/win
THIRD_PARTY_BASE_DIR: "third-party"
THIRD_PARTY_BASE_DIR: 'third-party'
jobs:
deps:
name: "Restore or build deps"
name: Restore or build deps
if: ${{ !cancelled() }}
uses: "./.github/workflows/emu-deps-win.yml"
uses: ./.github/workflows/emu-deps-win.yml
builds-matrix-win:
name: "build"
needs: ["deps"]
runs-on: "windows-2022"
name: build
needs: [ deps ]
runs-on: windows-2022
if: ${{ !cancelled() }}
continue-on-error: true
@ -33,82 +33,78 @@ jobs:
fail-fast: false
matrix:
prj: [
# regular api
"api_regular",
# (experimental) api + client
"api_experimental",
"steamclient_experimental_stub",
# client (experimental) + loader + extra dll + gameoverlaylib
"steamclient_experimental",
"steamclient_experimental_loader",
"steamclient_experimental_extra",
"lib_game_overlay_renderer",
# tools
"tool_lobby_connect",
"tool_generate_interfaces",
]
arch: ["x64", "Win32"]
cfg: ["debug", "release"]
# regular api
'api_regular',
# (experimental) api + client
'api_experimental', 'steamclient_experimental_stub',
# client (experimental) + loader + extra dll + gameoverlaylib
'steamclient_experimental', 'steamclient_experimental_loader',
'steamclient_experimental_extra', 'lib_game_overlay_renderer',
# tools
'tool_lobby_connect', 'tool_generate_interfaces',
]
arch: [ 'x64', 'Win32', ]
cfg: [ 'debug', 'release', ]
steps:
# on Windows Git will auto change line ending to CRLF, not preferable
- name: "Ensure LF line ending"
shell: "cmd"
working-directory: "${{ github.workspace }}"
### on Windows Git will auto change line ending to CRLF, not preferable
- name: Ensure LF line ending
shell: cmd
working-directory: ${{ github.workspace }}
run: |
git config --local core.autocrlf false
git config --system core.autocrlf false
git config --global core.autocrlf false
# ensure we have msbuild
- name: "Add MSBuild to PATH"
### ensure we have msbuild
- name: Add MSBuild to PATH
uses: microsoft/setup-msbuild@v2
# clone branch
- name: "Checkout branch"
### clone branch
- name: Checkout branch
uses: actions/checkout@v4
# deps
- name: "Restore deps"
id: "emu-deps-cache-step"
### deps
- name: Restore deps
id: emu-deps-cache-step
uses: actions/cache@v4
with:
key: "${{ env.DEPS_CACHE_KEY }}-${{ env.PREMAKE_ACTION }}"
path: "${{ env.DEPS_CACHE_DIR }}/${{ env.PREMAKE_ACTION }}"
key: ${{ env.DEPS_CACHE_KEY }}-${{ env.PREMAKE_ACTION }}
path: ${{ env.DEPS_CACHE_DIR }}/${{ env.PREMAKE_ACTION }}
# extra helpers/tools, these are not built inside the deps build dir
- name: "Clone third-party build helpers (common/win)"
## extra helpers/tools, these are not built inside the deps build dir
- name: Clone third-party build helpers (common/win)
uses: actions/checkout@v4
with:
ref: "third-party/common/win"
ref: 'third-party/common/win'
path: "${{env.THIRD_PARTY_BASE_DIR}}/common/win"
- name: "Clone third-party deps (build/win)"
- name: Clone third-party deps (build/win)
uses: actions/checkout@v4
with:
ref: "third-party/build/win"
ref: 'third-party/build/win'
path: "${{env.THIRD_PARTY_BASE_DIR}}/build/win"
# generate project files
- name: "Generate project files"
shell: "cmd"
working-directory: "${{ github.workspace }}"
### generate project files
- name: Generate project files
shell: cmd
working-directory: ${{ github.workspace }}
run: |
"${{env.THIRD_PARTY_BASE_DIR}}\common\win\premake\premake5.exe" --file=premake5.lua --genproto --emubuild=${{ github.sha }} --dosstub --winrsrc --winsign --os=windows vs2022
# build target
- name: "Build target"
shell: "cmd"
working-directory: "${{ github.workspace }}/build/project/vs2022/win"
### build target
- name: Build target
shell: cmd
working-directory: ${{ github.workspace }}/build/project/vs2022/win
run: |
msbuild /nologo /target:${{ matrix.prj }} /m:2 /v:n /p:Configuration=${{ matrix.cfg }},Platform=${{ matrix.arch }} gbe.sln
# upload artifact/package to github Actions
- name: "Upload target package"
### upload artifact/package to github Actions
- name: Upload target package
uses: actions/upload-artifact@v4
with:
name: "emu-win-${{ matrix.prj }}-${{ matrix.cfg }}-${{ matrix.arch }}-${{ github.sha }}"
path: "build/win"
if-no-files-found: "error"
if-no-files-found: 'error'
compression-level: 9
retention-days: 1

126
.github/workflows/emu-deps-linux.yml vendored
View File

@ -1,4 +1,4 @@
name: "Emu third-party dependencies (Linux)"
name: Emu third-party dependencies (Linux)
on:
workflow_call:
@ -7,82 +7,82 @@ on:
# allows manual trigger
permissions:
contents: "write"
contents: write
env:
PREMAKE_ACTION: "gmake2"
DEPS_CACHE_KEY: "emu-deps-linux"
DEPS_CACHE_DIR: "build/deps/linux"
PREMAKE_ACTION: gmake2
DEPS_CACHE_KEY: emu-deps-linux
DEPS_CACHE_DIR: build/deps/linux
PACKAGE_BASE_DIR: "build/package/linux"
THIRD_PARTY_BASE_DIR: "third-party"
THIRD_PARTY_BASE_DIR: 'third-party'
jobs:
deps-build:
runs-on: "ubuntu-20.04"
runs-on: ubuntu-24.04
if: ${{ !cancelled() }}
steps:
- name: "Lookup cache for deps"
id: "emu-deps-cache-step"
uses: actions/cache@v4
with:
key: "${{ env.DEPS_CACHE_KEY }}-${{ env.PREMAKE_ACTION }}"
path: "${{ env.DEPS_CACHE_DIR }}/${{ env.PREMAKE_ACTION }}"
- name: Lookup cache for deps
id: emu-deps-cache-step
uses: actions/cache@v4
with:
key: ${{ env.DEPS_CACHE_KEY }}-${{ env.PREMAKE_ACTION }}
path: ${{ env.DEPS_CACHE_DIR }}/${{ env.PREMAKE_ACTION }}
# we need branch because it has build scripts
- name: "Checkout branch"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
# we need branch because it has build scripts
- name: Checkout branch
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
- name: "Clone third-party deps (common/linux)"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: "third-party/common/linux"
path: "${{env.THIRD_PARTY_BASE_DIR}}/common/linux"
- name: Clone third-party deps (common/linux)
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: 'third-party/common/linux'
path: "${{env.THIRD_PARTY_BASE_DIR}}/common/linux"
- name: "Clone third-party deps (deps/linux)"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: "third-party/deps/linux"
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/linux"
- name: Clone third-party deps (deps/linux)
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: 'third-party/deps/linux'
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/linux"
- name: "Clone third-party deps (deps/common)"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: "third-party/deps/common"
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/common"
- name: Clone third-party deps (deps/common)
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: 'third-party/deps/common'
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/common"
# fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: "Give all permissions to repo folder"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
shell: "bash"
working-directory: "${{ github.workspace }}"
run: sudo chmod -R 777 "${{ github.workspace }}"
### fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: Give all permissions to repo folder
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
shell: bash
working-directory: ${{ github.workspace }}
run: sudo chmod -R 777 "${{ github.workspace }}"
# mandatory Linux packages
- name: "Install required packages"
shell: "bash"
run: |
sudo apt update -y
sudo apt install -y coreutils # echo, printf, etc...
sudo apt install -y build-essential
sudo apt install -y gcc-multilib # needed for 32-bit builds
sudo apt install -y g++-multilib
# sudo apt install -y clang
sudo apt install -y libglx-dev # needed for overlay build (header files such as GL/glx.h)
sudo apt install -y libgl-dev # needed for overlay build (header files such as GL/gl.h)
# sudo apt install -y binutils # (optional) contains the tool 'readelf' mainly, and other usefull binary stuff
## mandatory Linux packages
- name: Install required packages
shell: bash
run: |
sudo apt update -y
sudo apt install -y coreutils # echo, printf, etc...
sudo apt install -y build-essential
sudo apt install -y gcc-multilib # needed for 32-bit builds
sudo apt install -y g++-multilib
# sudo apt install -y clang
sudo apt install -y libglx-dev # needed for overlay build (header files such as GL/glx.h)
sudo apt install -y libgl-dev # needed for overlay build (header files such as GL/gl.h)
# sudo apt install -y binutils # (optional) contains the tool 'readelf' mainly, and other usefull binary stuff
- name: "Build deps"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
shell: "bash"
working-directory: "${{ github.workspace }}"
run: |
export CMAKE_GENERATOR="Unix Makefiles"
sudo chmod 777 ./${{env.THIRD_PARTY_BASE_DIR}}/common/linux/premake/premake5
./${{env.THIRD_PARTY_BASE_DIR}}/common/linux/premake/premake5 --file=premake5-deps.lua --64-build --32-build --all-ext --all-build --j=2 --verbose --clean --os=linux gmake2
- name: Build deps
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
shell: bash
working-directory: ${{ github.workspace }}
run: |
export CMAKE_GENERATOR="Unix Makefiles"
sudo chmod 777 ./${{env.THIRD_PARTY_BASE_DIR}}/common/linux/premake/premake5
./${{env.THIRD_PARTY_BASE_DIR}}/common/linux/premake/premake5 --file=premake5-deps.lua --64-build --32-build --all-ext --all-build --j=2 --verbose --clean --os=linux gmake2

114
.github/workflows/emu-deps-win.yml vendored
View File

@ -1,4 +1,4 @@
name: "Emu third-party dependencies (Windows)"
name: Emu third-party dependencies (Windows)
on:
workflow_call:
@ -7,76 +7,76 @@ on:
# allows manual trigger
permissions:
contents: "write"
contents: write
env:
PREMAKE_ACTION: "vs2022"
DEPS_CACHE_KEY: "emu-deps-win"
DEPS_CACHE_DIR: "build/deps/win"
PREMAKE_ACTION: vs2022
DEPS_CACHE_KEY: emu-deps-win
DEPS_CACHE_DIR: build/deps/win
PACKAGE_BASE_DIR: "build/package/win"
THIRD_PARTY_BASE_DIR: "third-party"
THIRD_PARTY_BASE_DIR: 'third-party'
jobs:
deps-build:
runs-on: "windows-2022"
runs-on: windows-2022
if: ${{ !cancelled() }}
steps:
# on Windows Git will auto change line ending to CRLF, not preferable
- name: "Ensure LF line ending"
shell: "cmd"
working-directory: ${{ github.workspace }}
run: |
git config --local core.autocrlf false
git config --system core.autocrlf false
git config --global core.autocrlf false
# on Windows Git will auto change line ending to CRLF, not preferable
- name: Ensure LF line ending
shell: cmd
working-directory: ${{ github.workspace }}
run: |
git config --local core.autocrlf false
git config --system core.autocrlf false
git config --global core.autocrlf false
- name: "Lookup cache for deps"
id: "emu-deps-cache-step"
uses: actions/cache@v4
with:
key: "${{ env.DEPS_CACHE_KEY }}-${{ env.PREMAKE_ACTION }}"
path: "${{ env.DEPS_CACHE_DIR }}/${{ env.PREMAKE_ACTION }}"
lookup-only: true # don't restore cache if found
- name: Lookup cache for deps
id: emu-deps-cache-step
uses: actions/cache@v4
with:
key: ${{ env.DEPS_CACHE_KEY }}-${{ env.PREMAKE_ACTION }}
path: ${{ env.DEPS_CACHE_DIR }}/${{ env.PREMAKE_ACTION }}
lookup-only: true # don't restore cache if found
# we need branch because it has build scripts
- name: "Checkout branch"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
# we need branch because it has build scripts
- name: Checkout branch
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
- name: "Clone third-party deps (common/win)"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: "third-party/common/win"
path: "${{env.THIRD_PARTY_BASE_DIR}}/common/win"
- name: Clone third-party deps (common/win)
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: 'third-party/common/win'
path: "${{env.THIRD_PARTY_BASE_DIR}}/common/win"
- name: "Clone third-party deps (deps/win)"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: "third-party/deps/win"
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/win"
- name: Clone third-party deps (deps/win)
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: 'third-party/deps/win'
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/win"
- name: "Clone third-party deps (deps/common)"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: "third-party/deps/common"
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/common"
- name: Clone third-party deps (deps/common)
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: 'third-party/deps/common'
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/common"
- name: "Clone third-party deps (common/win)"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: "third-party/common/win"
path: "${{env.THIRD_PARTY_BASE_DIR}}/common/win"
- name: Clone third-party deps (common/win)
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
uses: actions/checkout@v4
with:
ref: 'third-party/common/win'
path: "${{env.THIRD_PARTY_BASE_DIR}}/common/win"
- name: "Build deps"
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
shell: "cmd"
working-directory: "${{ github.workspace }}"
run: |
set "CMAKE_GENERATOR=Visual Studio 17 2022"
"${{env.THIRD_PARTY_BASE_DIR}}\common\win\premake\premake5.exe" --file=premake5-deps.lua --64-build --32-build --all-ext --all-build --j=2 --verbose --clean --os=windows vs2022
- name: Build deps
if: steps.emu-deps-cache-step.outputs.cache-hit != 'true'
shell: cmd
working-directory: ${{ github.workspace }}
run: |
set "CMAKE_GENERATOR=Visual Studio 17 2022"
"${{env.THIRD_PARTY_BASE_DIR}}\common\win\premake\premake5.exe" --file=premake5-deps.lua --64-build --32-build --all-ext --all-build --j=2 --verbose --clean --os=windows vs2022

32
.github/workflows/emu-pull-request.yml vendored
View File

@ -1,30 +1,30 @@
name: "Emu PR"
name: Emu PR
on:
pull_request:
branches: ["dev"]
branches: [ "dev" ]
paths-ignore:
- "**/*.md"
- "dev.notes/**"
- "post_build/**"
- "z_original_repo_files/**"
- "sdk/*.txt"
- "LICENSE"
- '**/*.md'
- 'dev.notes/**'
- 'post_build/**'
- 'z_original_repo_files/**'
- 'sdk/*.txt'
- 'LICENSE'
# tools
- "tools/generate_emu_config/**"
- "tools/migrate_gse/**"
- "tools/steamclient_loader/linux/**" # these are just scripts, not built
- 'tools/generate_emu_config/**'
- 'tools/migrate_gse/**'
- 'tools/steamclient_loader/linux/**' # these are just scripts, not built
permissions:
contents: "write"
contents: write
jobs:
emu-win-all:
name: "win"
name: win
if: ${{ !cancelled() }}
uses: "./.github/workflows/emu-build-all-win.yml"
uses: ./.github/workflows/emu-build-all-win.yml
emu-linux-all:
name: "linux"
name: linux
if: ${{ !cancelled() }}
uses: "./.github/workflows/emu-build-all-linux.yml"
uses: ./.github/workflows/emu-build-all-linux.yml

60
.github/workflows/gen_emu_config-build-linux.yml vendored
View File

@ -1,4 +1,4 @@
name: "Build gen_emu_config script (Linux)"
name: Build gen_emu_config script (Linux)
on:
workflow_call:
@ -7,7 +7,7 @@ on:
# allows manual trigger
permissions:
contents: "write"
contents: write
env:
ARTIFACT_NAME: "generate_emu_config-linux-${{ github.sha }}"
@ -16,37 +16,37 @@ env:
jobs:
build:
runs-on: "ubuntu-20.04"
runs-on: ubuntu-24.04
steps:
- name: "Checkout branch"
uses: actions/checkout@v4
- name: Checkout branch
uses: actions/checkout@v4
# env
- name: "Install env"
shell: "bash"
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: sudo chmod 777 recreate_venv_linux.sh && sudo ./recreate_venv_linux.sh
# env
- name: Install env
shell: bash
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: sudo chmod 777 recreate_venv_linux.sh && sudo ./recreate_venv_linux.sh
# fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: "Give all permissions to repo folder"
shell: "bash"
working-directory: "${{ github.workspace }}"
run: sudo chmod -R 777 "${{ github.workspace }}"
### fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: Give all permissions to repo folder
shell: bash
working-directory: ${{ github.workspace }}
run: sudo chmod -R 777 "${{ github.workspace }}"
# build
- name: "Rebuild"
shell: "bash"
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: sudo chmod 777 rebuild_linux.sh && ./rebuild_linux.sh
# build
- name: Rebuild
shell: bash
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: sudo chmod 777 rebuild_linux.sh && ./rebuild_linux.sh
# upload artifact
- name: "Upload build package"
uses: actions/upload-artifact@v4
with:
name: "${{ env.ARTIFACT_NAME }}"
path: "${{ env.PACKAGE_BASE_DIR }}/"
if-no-files-found: "error"
compression-level: 9
retention-days: 1
# upload artifact
- name: Upload build package
uses: actions/upload-artifact@v4
with:
name: "${{ env.ARTIFACT_NAME }}"
path: "${{ env.PACKAGE_BASE_DIR }}/"
if-no-files-found: 'error'
compression-level: 9
retention-days: 1

101
.github/workflows/gen_emu_config-build-win.yml vendored
View File

@ -1,4 +1,4 @@
name: "Build gen_emu_config script (Windows)"
name: Build gen_emu_config script (Windows)
on:
workflow_call:
@ -7,77 +7,62 @@ on:
# allows manual trigger
permissions:
contents: "write"
contents: write
env:
ARTIFACT_NAME: "generate_emu_config-win-${{ github.sha }}"
SCRIPT_BASE_DIR: "tools/generate_emu_config"
PACKAGE_BASE_DIR: "tools/generate_emu_config/bin/win"
THIRD_PARTY_BASE_DIR: "third-party"
THIRD_PARTY_BASE_DIR: 'third-party'
jobs:
build:
runs-on: "windows-2022"
runs-on: windows-2022
steps:
- name: "Set up Python"
uses: actions/setup-python@v5
with:
python-version: "3.12"
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: "3.12"
### on Windows Git will auto change line ending to CRLF, not preferable
- name: "Ensure LF line ending"
shell: "cmd"
working-directory: "${{ github.workspace }}"
run: |
git config --local core.autocrlf false
git config --system core.autocrlf false
git config --global core.autocrlf false
### on Windows Git will auto change line ending to CRLF, not preferable
- name: Ensure LF line ending
shell: cmd
working-directory: ${{ github.workspace }}
run: |
git config --local core.autocrlf false
git config --system core.autocrlf false
git config --global core.autocrlf false
- name: "Checkout branch"
uses: actions/checkout@v4
- name: Checkout branch
uses: actions/checkout@v4
## extra helpers/tools, these are not built inside the deps build dir
- name: "Clone third-party deps (build/win)"
uses: actions/checkout@v4
with:
ref: "third-party/build/win"
path: "${{env.THIRD_PARTY_BASE_DIR}}/build/win"
## extra helpers/tools, these are not built inside the deps build dir
- name: Clone third-party deps (build/win)
uses: actions/checkout@v4
with:
ref: 'third-party/build/win'
path: "${{env.THIRD_PARTY_BASE_DIR}}/build/win"
## clone this for 7za.exe
- name: "Clone third-party deps (deps/win)"
uses: actions/checkout@v4
with:
ref: "third-party/deps/win"
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/win"
# env
- name: Install env
shell: cmd
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: recreate_venv_win.bat
# download artifacts
- name: "Download emu build artifacts (Win)"
uses: actions/download-artifact@v4
with:
path: "build/win"
pattern: "emu-win-*"
merge-multiple: true
# build
- name: Rebuild
shell: cmd
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: rebuild_win.bat
# env
- name: "Install env"
shell: "cmd"
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: recreate_venv_win.bat
# build
- name: "Rebuild"
shell: "cmd"
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: rebuild_win.bat
# upload artifact
- name: "Upload build package"
uses: actions/upload-artifact@v4
with:
name: "${{ env.ARTIFACT_NAME }}"
path: "${{ env.PACKAGE_BASE_DIR }}/"
if-no-files-found: "error"
compression-level: 9
retention-days: 1
# upload artifact
- name: Upload build package
uses: actions/upload-artifact@v4
with:
name: "${{ env.ARTIFACT_NAME }}"
path: "${{ env.PACKAGE_BASE_DIR }}/"
if-no-files-found: 'error'
compression-level: 9
retention-days: 1

18
.github/workflows/gen_emu_config-pull-request.yml vendored
View File

@ -1,22 +1,22 @@
name: "Gen emu cfg PR"
name: Gen emu cfg PR
on:
pull_request:
branches: ["dev"]
branches: [ "dev" ]
paths:
- "!**/*.md"
- "tools/generate_emu_config/**"
- '!**/*.md'
- 'tools/generate_emu_config/**'
permissions:
contents: "write"
contents: write
jobs:
script-win:
name: "Gen emu config win"
name: Gen emu config win
if: ${{ !cancelled() }}
uses: "./.github/workflows/gen_emu_config-build-win.yml"
uses: ./.github/workflows/gen_emu_config-build-win.yml
script-linux:
name: "Gen emu config linux"
name: Gen emu config linux
if: ${{ !cancelled() }}
uses: "./.github/workflows/gen_emu_config-build-linux.yml"
uses: ./.github/workflows/gen_emu_config-build-linux.yml

60
.github/workflows/migrate_gse-build-linux.yml vendored
View File

@ -1,4 +1,4 @@
name: "Build migrate_gse script (Linux)"
name: Build migrate_gse script (Linux)
on:
workflow_call:
@ -7,7 +7,7 @@ on:
# allows manual trigger
permissions:
contents: "write"
contents: write
env:
ARTIFACT_NAME: "migrate_gse-linux-${{ github.sha }}"
@ -16,37 +16,37 @@ env:
jobs:
build:
runs-on: "ubuntu-20.04"
runs-on: ubuntu-24.04
steps:
- name: "Checkout branch"
uses: actions/checkout@v4
- name: Checkout branch
uses: actions/checkout@v4
# fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: "Give all permissions to repo folder"
shell: "bash"
working-directory: "${{ github.workspace }}"
run: sudo chmod -R 777 "${{ github.workspace }}"
### fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: Give all permissions to repo folder
shell: bash
working-directory: ${{ github.workspace }}
run: sudo chmod -R 777 "${{ github.workspace }}"
# env
- name: "Install env"
shell: "bash"
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: sudo chmod 777 recreate_venv_linux.sh && sudo ./recreate_venv_linux.sh
# env
- name: Install env
shell: bash
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: sudo chmod 777 recreate_venv_linux.sh && sudo ./recreate_venv_linux.sh
# build
- name: "Rebuild"
shell: "bash"
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: sudo chmod 777 rebuild_linux.sh && ./rebuild_linux.sh
# build
- name: Rebuild
shell: bash
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: sudo chmod 777 rebuild_linux.sh && ./rebuild_linux.sh
# upload artifact
- name: "Upload build package"
uses: actions/upload-artifact@v4
with:
name: "${{ env.ARTIFACT_NAME }}"
path: "${{ env.PACKAGE_BASE_DIR }}/"
if-no-files-found: "error"
compression-level: 9
retention-days: 1
# upload artifact
- name: Upload build package
uses: actions/upload-artifact@v4
with:
name: "${{ env.ARTIFACT_NAME }}"
path: "${{ env.PACKAGE_BASE_DIR }}/"
if-no-files-found: 'error'
compression-level: 9
retention-days: 1

101
.github/workflows/migrate_gse-build-win.yml vendored
View File

@ -1,4 +1,4 @@
name: "Build migrate_gse script (Windows)"
name: Build migrate_gse script (Windows)
on:
workflow_call:
@ -7,77 +7,62 @@ on:
# allows manual trigger
permissions:
contents: "write"
contents: write
env:
ARTIFACT_NAME: "migrate_gse-win-${{ github.sha }}"
SCRIPT_BASE_DIR: "tools/migrate_gse"
PACKAGE_BASE_DIR: "tools/migrate_gse/bin/win"
THIRD_PARTY_BASE_DIR: "third-party"
THIRD_PARTY_BASE_DIR: 'third-party'
jobs:
build:
runs-on: "windows-2022"
runs-on: windows-2022
steps:
- name: "Set up Python 3.12"
uses: actions/setup-python@v5
with:
python-version: "3.12"
- name: Set up Python 3.12
uses: actions/setup-python@v5
with:
python-version: "3.12"
# on Windows Git will auto change line ending to CRLF, not preferable
- name: "Ensure LF line ending"
shell: "cmd"
working-directory: "${{ github.workspace }}"
run: |
git config --local core.autocrlf false
git config --system core.autocrlf false
git config --global core.autocrlf false
### on Windows Git will auto change line ending to CRLF, not preferable
- name: Ensure LF line ending
shell: cmd
working-directory: ${{ github.workspace }}
run: |
git config --local core.autocrlf false
git config --system core.autocrlf false
git config --global core.autocrlf false
- name: "Checkout branch"
uses: actions/checkout@v4
- name: Checkout branch
uses: actions/checkout@v4
# extra helpers/tools, these are not built inside the deps build dir
- name: "Clone third-party deps (build/win)"
uses: actions/checkout@v4
with:
ref: "third-party/build/win"
path: "${{env.THIRD_PARTY_BASE_DIR}}/build/win"
## extra helpers/tools, these are not built inside the deps build dir
- name: Clone third-party deps (build/win)
uses: actions/checkout@v4
with:
ref: 'third-party/build/win'
path: "${{env.THIRD_PARTY_BASE_DIR}}/build/win"
## clone this for 7za.exe
- name: "Clone third-party deps (deps/win)"
uses: actions/checkout@v4
with:
ref: "third-party/deps/win"
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/win"
# env
- name: Install env
shell: cmd
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: recreate_venv_win.bat
# download artifacts
- name: "Download emu build artifacts (Win)"
uses: actions/download-artifact@v4
with:
path: "build/win"
pattern: "emu-win-*"
merge-multiple: true
# build
- name: Rebuild
shell: cmd
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: rebuild_win.bat
# env
- name: "Install env"
shell: cmd
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: recreate_venv_win.bat
# build
- name: "Rebuild"
shell: cmd
working-directory: "${{ env.SCRIPT_BASE_DIR }}"
run: rebuild_win.bat
# upload artifact
- name: "Upload build package"
uses: actions/upload-artifact@v4
with:
name: "${{ env.ARTIFACT_NAME }}"
path: "${{ env.PACKAGE_BASE_DIR }}/"
if-no-files-found: "error"
compression-level: 9
retention-days: 1
# upload artifact
- name: Upload build package
uses: actions/upload-artifact@v4
with:
name: "${{ env.ARTIFACT_NAME }}"
path: "${{ env.PACKAGE_BASE_DIR }}/"
if-no-files-found: 'error'
compression-level: 9
retention-days: 1

18
.github/workflows/migrate_gse-pull-request.yml vendored
View File

@ -1,22 +1,22 @@
name: "Migrate GSE PR"
name: Migrate GSE PR
on:
pull_request:
branches: ["dev"]
branches: [ "dev" ]
paths:
- "!**/*.md"
- "tools/migrate_gse/**"
- '!**/*.md'
- 'tools/migrate_gse/**'
permissions:
contents: "write"
contents: write
jobs:
script-win:
name: "Migrate GSE win"
name: Migrate GSE win
if: ${{ !cancelled() }}
uses: "./.github/workflows/migrate_gse-build-win.yml"
uses: ./.github/workflows/migrate_gse-build-win.yml
script-linux:
name: "Migrate GSE linux"
name: Migrate GSE linux
if: ${{ !cancelled() }}
uses: "./.github/workflows/migrate_gse-build-linux.yml"
uses: ./.github/workflows/migrate_gse-build-linux.yml

363
.github/workflows/release.yml vendored
View File

@ -1,415 +1,430 @@
name: "Prepare release"
name: Prepare release
on:
push:
tags:
- "release-*"
- release-*
workflow_dispatch:
# allows manual trigger
permissions:
contents: "write"
contents: write
env:
THIRD_PARTY_BASE_DIR: "third-party"
THIRD_PARTY_BASE_DIR: 'third-party'
jobs:
emu-win-all:
name: "Emu win all"
name: Emu win all
if: ${{ !cancelled() }}
uses: "./.github/workflows/emu-build-all-win.yml"
uses: ./.github/workflows/emu-build-all-win.yml
emu-win-prep:
needs: ["emu-win-all"]
runs-on: "windows-2022"
needs: [ emu-win-all ]
runs-on: windows-2022
steps:
# on Windows Git will auto change line ending to CRLF, not preferable
- name: "Ensure LF line ending"
shell: "cmd"
working-directory: "${{ github.workspace }}"
- name: Ensure LF line ending
shell: cmd
working-directory: ${{ github.workspace }}
run: |
git config --local core.autocrlf false
git config --system core.autocrlf false
git config --global core.autocrlf false
# we need branch because it has package scripts
- name: "Checkout branch"
- name: Checkout branch
uses: actions/checkout@v4
- name: "Clone third-party deps (deps/win)"
- name: Clone third-party deps (deps/win)
uses: actions/checkout@v4
with:
ref: "third-party/deps/win"
ref: 'third-party/deps/win'
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/win"
# download artifacts
- name: "Download emu build artifacts (Win)"
## donwload artifacts
- name: Download emu build artifacts (Win)
uses: actions/download-artifact@v4
with:
path: "build/win"
pattern: "emu-win-*-${{ github.sha }}"
path: build/win
pattern: emu-win-*-${{ github.sha }}
merge-multiple: true
# print files
- name: "Print files"
shell: "cmd"
working-directory: "${{ github.workspace }}"
### print files
- name: Print files
shell: cmd
working-directory: ${{ github.workspace }}
run: |
dir /s /b /a:-d build\win
# package (release mode)
- name: "Package build (release)"
shell: "cmd"
working-directory: "${{ github.workspace }}"
### remove linker files
### - name: Remove linker files
### shell: cmd
### working-directory: ${{ github.workspace }}
### run: |
### del /f /s /q build\win\*.exp,build\win\*.lib
### exit /b 0
### package (release mode)
- name: Package build (release)
shell: cmd
working-directory: ${{ github.workspace }}
run: package_win.bat vs2022\release
# package (debug mode)
- name: "Package build (debug)"
shell: "cmd"
working-directory: "${{ github.workspace }}"
### package (debug mode)
- name: Package build (debug)
shell: cmd
working-directory: ${{ github.workspace }}
run: package_win.bat vs2022\debug 1
# release (debug + release modes) if this is a tag push
- name: "Release"
### release (debug + release modes) if this is a tag push
- name: Release
if: startsWith(github.ref, 'refs/tags/')
uses: softprops/action-gh-release@v2
uses: softprops/action-gh-release@v1
with:
files: "build/package/win/**/*"
# upload artifacts/packages if this is a manual run
- name: "Upload release package"
### upload artifacts/packages if this is a manual run
- name: Upload release package
if: ${{ !startsWith(github.ref, 'refs/tags/') }}
uses: actions/upload-artifact@v4
with:
name: "release-emu-win-release-${{ github.sha }}"
path: "build/package/win/vs2022/*release*"
if-no-files-found: "error"
if-no-files-found: 'error'
compression-level: 0
retention-days: 7
- name: "Upload debug package"
- name: Upload debug package
if: ${{ !startsWith(github.ref, 'refs/tags/') }}
uses: actions/upload-artifact@v4
with:
name: "release-emu-win-debug-${{ github.sha }}"
path: "build/package/win/vs2022/*debug*"
if-no-files-found: "error"
if-no-files-found: 'error'
compression-level: 0
retention-days: 7
emu-linux-all:
name: "Emu linux all"
name: Emu linux all
if: ${{ !cancelled() }}
uses: "./.github/workflows/emu-build-all-linux.yml"
uses: ./.github/workflows/emu-build-all-linux.yml
emu-linux-prep:
needs: ["emu-linux-all"]
runs-on: "ubuntu-20.04"
needs: [ emu-linux-all ]
runs-on: ubuntu-24.04
steps:
# we need branch because it has package scripts
- name: "Checkout branch"
- name: Checkout branch
uses: actions/checkout@v4
- name: "Clone third-party deps (deps/linux)"
- name: Clone third-party deps (deps/linux)
uses: actions/checkout@v4
with:
ref: "third-party/deps/linux"
ref: 'third-party/deps/linux'
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/linux"
# download artifacts
- name: "Download emu build artifacts (linux)"
## donwload artifacts
- name: Download emu build artifacts (linux)
uses: actions/download-artifact@v4
with:
path: "build/linux"
pattern: "emu-linux-*-${{ github.sha }}"
path: build/linux
pattern: emu-linux-*-${{ github.sha }}
merge-multiple: true
# fix folder permissions! not sure why this fails
### fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: "Give all permissions to repo folder"
shell: "bash"
working-directory: "${{ github.workspace }}"
- name: Give all permissions to repo folder
shell: bash
working-directory: ${{ github.workspace }}
run: sudo chmod -R 777 "${{ github.workspace }}" && sudo chmod 777 package_linux.sh
# print files
- name: "Print files"
shell: "bash"
working-directory: "${{ github.workspace }}"
### print files
- name: Print files
shell: bash
working-directory: ${{ github.workspace }}
run: |
ls -la build/linux/*/*
# downlaod ubuntu packages
- name: "Download required Ubuntu packages"
shell: "bash"
working-directory: "${{ github.workspace }}"
### downlaod ubuntu packages
- name: Download required Ubuntu packages
shell: bash
working-directory: ${{ github.workspace }}
run: |
sudo apt update || exit 1
sudo apt install tar -y || exit 1
# package (release mode)
- name: "Package build (release)"
shell: "bash"
working-directory: "${{ github.workspace }}"
### package (release mode)
- name: Package build (release)
shell: bash
working-directory: ${{ github.workspace }}
run: ./package_linux.sh gmake2/release
# package (debug mode)
- name: "Package build (debug)"
shell: "bash"
working-directory: "${{ github.workspace }}"
### package (debug mode)
- name: Package build (debug)
shell: bash
working-directory: ${{ github.workspace }}
run: ./package_linux.sh gmake2/debug 1
# release (debug + release modes) if this is a tag push
- name: "Release"
### release (debug + release modes) if this is a tag push
- name: Release
if: startsWith(github.ref, 'refs/tags/')
uses: softprops/action-gh-release@v2
uses: softprops/action-gh-release@v1
with:
files: "build/package/linux/**/*"
# upload artifacts/packages if this is a manual run
- name: "Upload release package"
### upload artifacts/packages if this is a manual run
- name: Upload release package
if: ${{ !startsWith(github.ref, 'refs/tags/') }}
uses: actions/upload-artifact@v4
with:
name: "release-emu-linux-release-${{ github.sha }}"
path: "build/package/linux/gmake2/*release*"
if-no-files-found: "error"
if-no-files-found: 'error'
compression-level: 0
retention-days: 7
- name: "Upload debug package"
- name: Upload debug package
if: ${{ !startsWith(github.ref, 'refs/tags/') }}
uses: actions/upload-artifact@v4
with:
name: "release-emu-linux-debug-${{ github.sha }}"
path: "build/package/linux/gmake2/*debug*"
if-no-files-found: "error"
if-no-files-found: 'error'
compression-level: 0
retention-days: 7
gen_emu_script-win:
needs: ["emu-win-all"] # add emu-win-all to wait for emu build to complete, so that we include the latest dlls and tools in generate_emu_config
name: "Gen emu config win"
name: Gen emu config win
if: ${{ !cancelled() }}
uses: "./.github/workflows/gen_emu_config-build-win.yml"
uses: ./.github/workflows/gen_emu_config-build-win.yml
gen_emu_script-win-prep:
needs: ["gen_emu_script-win"]
runs-on: "windows-2022"
needs: [ gen_emu_script-win ]
runs-on: windows-2022
steps:
# on Windows Git will auto change line ending to CRLF, not preferable
- name: "Ensure LF line ending"
shell: "cmd"
working-directory: "${{ github.workspace }}"
- name: Ensure LF line ending
shell: cmd
working-directory: ${{ github.workspace }}
run: |
git config --local core.autocrlf false
git config --system core.autocrlf false
git config --global core.autocrlf false
# we need branch because it has package scripts
- name: "Checkout branch"
- name: Checkout branch
uses: actions/checkout@v4
- name: "Clone third-party deps (deps/win)"
- name: Clone third-party deps (deps/win)
uses: actions/checkout@v4
with:
ref: "third-party/deps/win"
ref: 'third-party/deps/win'
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/win"
# download artifacts
- name: "Download script build artifacts (Win)"
## donwload artifacts
- name: Download script build artifacts (Win)
uses: actions/download-artifact@v4
with:
path: "tools/generate_emu_config/bin/win"
pattern: "generate_emu_config-win-*"
path: tools/generate_emu_config/bin/win
pattern: generate_emu_config-win-*
merge-multiple: true
# package
- name: "Package script"
shell: "cmd"
### package
- name: Package script
shell: cmd
working-directory: "tools/generate_emu_config"
run: package_win.bat
# release tag
- name: "Release"
# release tag
- name: Release
if: startsWith(github.ref, 'refs/tags/')
uses: softprops/action-gh-release@v2
uses: softprops/action-gh-release@v1
with:
files: "tools/generate_emu_config/bin/package/win/**/*"
# upload artifact/package if this is a manual run
- name: "Upload release package"
### upload artifact/package if this is a manual run
- name: Upload release package
if: ${{ !startsWith(github.ref, 'refs/tags/') }}
uses: actions/upload-artifact@v4
with:
name: "release-generate_emu_config-win-${{ github.sha }}"
path: "tools/generate_emu_config/bin/package/win/**/*"
if-no-files-found: "error"
if-no-files-found: 'error'
compression-level: 9
retention-days: 7
gen_emu_script-linux:
needs: ["emu-linux-all"] # add emu-linux-all to wait for emu build to complete (not really needed but included for better build matrix visualization)
name: "Gen emu config linux"
name: Gen emu config linux
if: ${{ !cancelled() }}
uses: "./.github/workflows/gen_emu_config-build-linux.yml"
uses: ./.github/workflows/gen_emu_config-build-linux.yml
gen_emu_script-linux-prep:
needs: ["gen_emu_script-linux"]
runs-on: "ubuntu-20.04"
needs: [ gen_emu_script-linux ]
runs-on: ubuntu-24.04
steps:
# we need branch because it has package scripts
- name: "Checkout branch"
- name: Checkout branch
uses: actions/checkout@v4
# download artifacts
- name: "Download script build artifacts (linux)"
## donwload artifacts
- name: Download script build artifacts (linux)
uses: actions/download-artifact@v4
with:
path: "tools/generate_emu_config/bin/linux"
pattern: "generate_emu_config-linux-*"
path: tools/generate_emu_config/bin/linux
pattern: generate_emu_config-linux-*
merge-multiple: true
# fix folder permissions! not sure why this fails
### fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: "Give all permissions to repo folder"
shell: "bash"
working-directory: "${{ github.workspace }}"
run: sudo chmod -R 777 "${{ github.workspace }}"
- name: Give all permissions to repo folder
shell: bash
working-directory: ${{ github.workspace }}
run: sudo chmod -R 777 "${{ github.workspace }}"
# package
- name: "Package script"
shell: "bash"
### package
- name: Package script
shell: bash
working-directory: "tools/generate_emu_config"
run: sudo chmod 777 package_linux.sh && sudo ./package_linux.sh
# release tag
- name: "Release"
# release tag
- name: Release
if: startsWith(github.ref, 'refs/tags/')
uses: softprops/action-gh-release@v2
uses: softprops/action-gh-release@v1
with:
files: "tools/generate_emu_config/bin/package/linux/**/*"
# upload artifact/package if this is a manual run
- name: "Upload release package"
### upload artifact/package if this is a manual run
- name: Upload release package
if: ${{ !startsWith(github.ref, 'refs/tags/') }}
uses: actions/upload-artifact@v4
with:
name: "release-generate_emu_config-linux-${{ github.sha }}"
path: "tools/generate_emu_config/bin/package/linux/**/*"
if-no-files-found: "error"
if-no-files-found: 'error'
compression-level: 9
retention-days: 7
migrate_gse_script-win:
needs: ["emu-win-all"] # add emu-win-all to wait for emu build to complete, so that we include the latest dlls and tools in migrate_gse
name: "Migrate GSE win"
name: Migrate GSE win
if: ${{ !cancelled() }}
uses: "./.github/workflows/migrate_gse-build-win.yml"
uses: ./.github/workflows/migrate_gse-build-win.yml
migrate_gse_script-win-prep:
needs: ["migrate_gse_script-win"]
runs-on: "windows-2022"
needs: [ migrate_gse_script-win ]
runs-on: windows-2022
steps:
# on Windows Git will auto change line ending to CRLF, not preferable
- name: "Ensure LF line ending"
shell: "cmd"
working-directory: "${{ github.workspace }}"
- name: Ensure LF line ending
shell: cmd
working-directory: ${{ github.workspace }}
run: |
git config --local core.autocrlf false
git config --system core.autocrlf false
git config --global core.autocrlf false
# we need branch because it has package scripts
- name: "Checkout branch"
- name: Checkout branch
uses: actions/checkout@v4
- name: "Clone third-party deps (deps/win)"
- name: Clone third-party deps (deps/win)
uses: actions/checkout@v4
with:
ref: "third-party/deps/win"
ref: 'third-party/deps/win'
path: "${{env.THIRD_PARTY_BASE_DIR}}/deps/win"
# download artifacts
- name: "Download script build artifacts (Win)"
## donwload artifacts
- name: Download script build artifacts (Win)
uses: actions/download-artifact@v4
with:
path: "tools/migrate_gse/bin/win"
pattern: "migrate_gse-win-*"
path: tools/migrate_gse/bin/win
pattern: migrate_gse-win-*
merge-multiple: true
# package
- name: "Package script"
shell: "cmd"
### package
- name: Package script
shell: cmd
working-directory: "tools/migrate_gse"
run: package_win.bat
# release tag
- name: "Release"
# release tag
- name: Release
if: startsWith(github.ref, 'refs/tags/')
uses: softprops/action-gh-release@v2
uses: softprops/action-gh-release@v1
with:
files: "tools/migrate_gse/bin/package/win/**/*"
# upload artifact/package if this is a manual run
- name: "Upload release package"
### upload artifact/package if this is a manual run
- name: Upload release package
if: ${{ !startsWith(github.ref, 'refs/tags/') }}
uses: actions/upload-artifact@v4
with:
name: "release-migrate_gse-win-${{ github.sha }}"
path: "tools/migrate_gse/bin/package/win/**/*"
if-no-files-found: "error"
if-no-files-found: 'error'
compression-level: 9
retention-days: 7
migrate_gse_script-linux:
needs: ["emu-linux-all"] # add emu-linux-all to wait for emu build to complete (not really needed but included for better build matrix visualization)
name: Migrate GSE linux
if: ${{ !cancelled() }}
uses: "./.github/workflows/migrate_gse-build-linux.yml"
uses: ./.github/workflows/migrate_gse-build-linux.yml
migrate_gse_script-linux-prep:
needs: ["migrate_gse_script-linux"]
runs-on: "ubuntu-20.04"
needs: [ migrate_gse_script-linux ]
runs-on: ubuntu-24.04
steps:
# we need branch because it has package scripts
- name: "Checkout branch"
- name: Checkout branch
uses: actions/checkout@v4
# download artifacts
- name: "Download script build artifacts (linux)"
## donwload artifacts
- name: Download script build artifacts (linux)
uses: actions/download-artifact@v4
with:
path: "tools/migrate_gse/bin/linux"
pattern: "migrate_gse-linux-*"
path: tools/migrate_gse/bin/linux
pattern: migrate_gse-linux-*
merge-multiple: true
# fix folder permissions! not sure why this fails
### fix folder permissions! not sure why this fails
# nested subdirs "build/linux/release" cause permission problems
- name: "Give all permissions to repo folder"
shell: "bash"
working-directory: "${{ github.workspace }}"
run: sudo chmod -R 777 "${{ github.workspace }}"
- name: Give all permissions to repo folder
shell: bash
working-directory: ${{ github.workspace }}
run: sudo chmod -R 777 "${{ github.workspace }}"
# package
- name: "Package script"
shell: "bash"
### package
- name: Package script
shell: bash
working-directory: "tools/migrate_gse"
run: sudo chmod 777 package_linux.sh && sudo ./package_linux.sh
# release tag
- name: "Release"
# release tag
- name: Release
if: startsWith(github.ref, 'refs/tags/')
uses: softprops/action-gh-release@v2
uses: softprops/action-gh-release@v1
with:
files: "tools/migrate_gse/bin/package/linux/**/*"
# upload artifact/package if this is a manual run
- name: "Upload release package"
### upload artifact/package if this is a manual run
- name: Upload release package
if: ${{ !startsWith(github.ref, 'refs/tags/') }}
uses: actions/upload-artifact@v4
with:
name: "release-migrate_gse-linux-${{ github.sha }}"
path: "tools/migrate_gse/bin/package/linux/**/*"
if-no-files-found: "error"
if-no-files-found: 'error'
compression-level: 9
retention-days: 7

73
.gitignore vendored
View File

@ -1,67 +1,30 @@
# IDE
**/.vs
**/.vscode
/.vs/
/.vscode/
# PYTHON
**/.venv
**/__pycache__
/build/
# PROTOBUF
/proto_gen
/proto_gen/
# SPECIFIC
/build
/third-party
/crash_printer/tests/crash_test/
/resources/win/file_dos_stub/build/
# TOOLS
# generate_emu_config
/tools/generate_emu_config/.py*/
/tools/generate_emu_config/.venv*/
/tools/generate_emu_config/.env*/
/tools/generate_emu_config/bin
/tools/generate_emu_config/_DEFAULT/0/steam_api.dll
/tools/generate_emu_config/_DEFAULT/0/steam_api.7z
/tools/generate_emu_config/_DEFAULT/0/steam_api64.dll
/tools/generate_emu_config/_DEFAULT/0/steam_api64.7z
/tools/generate_emu_config/_DEFAULT/0/steam_api.7z
/tools/generate_emu_config/_DEFAULT/0/steam_api64.dll
/tools/generate_emu_config/_DEFAULT/0/steam_api64.7z
/tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/generate_interfaces/generate_interfaces.7z
/tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/generate_interfaces/generate_interfaces.exe
/tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/generate_interfaces/generate_interfaces64.exe
/tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/lobby_connect/lobby_connect.7z
/tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/lobby_connect/lobby_connect.exe
/tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/lobby_connect/lobby_connect64.exe
/tools/generate_emu_config/_OUTPUT/
/tools/generate_emu_config/.vscode/
/tools/generate_emu_config/backup/
/tools/generate_emu_config/bin/
/tools/generate_emu_config/login_temp/
/tools/generate_emu_config/output/
/tools/generate_emu_config/**/__pycache__/
/tools/generate_emu_config/**/my_login.txt
/tools/generate_emu_config/top_owners_ids.txt
# migrate_gse
/tools/migrate_gse/.py*/
/tools/migrate_gse/.venv*/
/tools/migrate_gse/.env*/
/tools/migrate_gse/bin
/tools/migrate_gse/.vscode/
/tools/migrate_gse/bin/
/tools/migrate_gse/**/__pycache__/
/tools/migrate_gse/_DEFAULT/0/steam_api.dll
/tools/migrate_gse/_DEFAULT/0/steam_api.7z
/tools/migrate_gse/_DEFAULT/0/steam_api64.dll
/tools/migrate_gse/_DEFAULT/0/steam_api64.7z
/tools/migrate_gse/_DEFAULT/0/steam_api.7z
/tools/migrate_gse/_DEFAULT/0/steam_api64.dll
/tools/migrate_gse/_DEFAULT/0/steam_api64.7z
/tools/migrate_gse/_DEFAULT/0/steam_misc/tools/generate_interfaces/generate_interfaces.7z
/tools/migrate_gse/_DEFAULT/0/steam_misc/tools/generate_interfaces/generate_interfaces.exe
/tools/migrate_gse/_DEFAULT/0/steam_misc/tools/generate_interfaces/generate_interfaces64.exe
/tools/migrate_gse/_DEFAULT/0/steam_misc/tools/lobby_connect/lobby_connect.7z
/tools/migrate_gse/_DEFAULT/0/steam_misc/tools/lobby_connect/lobby_connect.exe
/tools/migrate_gse/_DEFAULT/0/steam_misc/tools/lobby_connect/lobby_connect64.exe
/tools/migrate_gse/_OUTPUT/
/third-party/

1
.gitmodules vendored
View File

@ -1,3 +1,4 @@
[submodule "third-party/build/win"]
path = third-party/build/win
url = ./

7
CREDITS.md
View File

@ -24,7 +24,6 @@
- [libs\stb](#libsstb)
- [libs\utfcpp](#libsutfcpp)
- [tools\steamclient_loader](#toolssteamclient_loader)
- [sdk](#sdk)
### third-party\build\win\cert\openssl
@ -2548,9 +2547,3 @@ DEALINGS IN THE SOFTWARE.
https://github.com/Rat431/ColdAPI_Steam
Original version of ColdClientLoader by Rat431.
### sdk
#### INFO
https://partner.steamgames.com/doc/sdk

2
README.md
View File

@ -106,7 +106,7 @@ You can also find instructions here in [README.release.md](./post_build/README.r
### For Linux:
* Ubuntu 20.04 LTS: https://ubuntu.com/download/desktop
* Ubuntu 22.04 LTS: https://ubuntu.com/download/desktop
* Ubuntu required packages:
```shell
sudo apt update -y

31
build_win_premake.bat
View File

@ -21,7 +21,7 @@ set /a "BUILD_DEPS=0"
) else if "%~1" equ "--help" (
goto :help_page
) else (
1>&2 echo:invalid arg %~1
1>&2 echo: invalid arg %~1
goto :end_script_with_err
)
@ -32,14 +32,15 @@ set /a "BUILD_DEPS=0"
:: check premake
set "PREMAKE_EXE=third-party\common\win\premake\premake5.exe"
if not exist "%PREMAKE_EXE%" (
1>&2 echo:premake wasn't found
1>&2 echo: premake wasn't found
goto :end_script_with_err
)
:: build deps
if %BUILD_DEPS% equ 1 (
set "CMAKE_GENERATOR=Visual Studio 17 2022"
call "%PREMAKE_EXE%" --file="premake5-deps.lua" --64-build --32-build --all-ext --all-build --j=2 --verbose --clean --os=windows vs2022 || (
call "%PREMAKE_EXE%" --file="premake5-deps.lua" --64-build --32-build --all-ext --all-build --j=2 --verbose --clean --os=windows vs2022
if !errorlevel! neq 0 (
goto :end_script_with_err
)
goto :end_script
@ -48,7 +49,7 @@ set /a "BUILD_DEPS=0"
:: check vswhere
set "VSWHERE_EXE=third-party\common\win\vswhere\vswhere.exe"
if not exist "%VSWHERE_EXE%" (
1>&2 echo:vswhere wasn't found
1>&2 echo: vswhere wasn't found
goto :end_script_with_err
)
@ -58,19 +59,20 @@ set /a "BUILD_DEPS=0"
set "MSBUILD_EXE=%%~A\MSBuild\Current\Bin\MSBuild.exe"
)
if not exist "%MSBUILD_EXE%" (
1>&2 echo:MSBuild wasn't found
1>&2 echo: MSBuild wasn't found
goto :end_script_with_err
)
:: create .sln
call "%PREMAKE_EXE%" --file="premake5.lua" --genproto --dosstub --winrsrc --winsign --os=windows vs2022 || (
call "%PREMAKE_EXE%" --file="premake5.lua" --genproto --dosstub --winrsrc --winsign --os=windows vs2022
if %errorlevel% neq 0 (
goto :end_script_with_err
)
:: check .sln
set "SLN_FILE=build\project\vs2022\win\gbe.sln"
if not exist "%SLN_FILE%" (
1>&2 echo:.sln file wasn't found
1>&2 echo: .sln file wasn't found
goto :end_script_with_err
)
@ -85,8 +87,9 @@ set /a "BUILD_DEPS=0"
set "BUILD_PLATFORM=%%B"
for %%C in (%BUILD_TARGETS%) do (
set "BUILD_TARGET=%%C"
echo. & echo:building !BUILD_TARGET! !BUILD_TYPE! !BUILD_PLATFORM!
call "%MSBUILD_EXE%" /nologo -m:%MAX_THREADS% -v:n /p:Configuration=!BUILD_TYPE!,Platform=!BUILD_PLATFORM! /target:!BUILD_TARGET! "%SLN_FILE%" || (
echo. & echo: building !BUILD_TARGET! !BUILD_TYPE! !BUILD_PLATFORM!
call "%MSBUILD_EXE%" /nologo -m:%MAX_THREADS% -v:n /p:Configuration=!BUILD_TYPE!,Platform=!BUILD_PLATFORM! /target:!BUILD_TARGET! "%SLN_FILE%"
if !errorlevel! neq 0 (
goto :end_script_with_err
)
)
@ -95,18 +98,20 @@ set /a "BUILD_DEPS=0"
goto :end_script
:: exit without error
:end_script
endlocal
exit /b 0
:: exit with error
:end_script_with_err
endlocal
exit /b 1
:: show help page
:help_page
echo:"%~nx0" [switches]
echo:switches:
echo: --deps: rebuild third-party dependencies
echo: --help: show this page
echo: "%~nx0" [switches]
echo: switches:
echo: --deps: rebuild third-party dependencies
echo: --help: show this page
goto :end_script

3
build_win_premake_gemu.bat
View File

@ -1,3 +0,0 @@
@echo off
call "build_win_premake.bat"

228
dll/client_known_interfaces.cpp
View File

@ -1,228 +0,0 @@
#include "dll/client_known_interfaces.h"
/*
the client function Steam_IsKnownInterface() accesses a structure which has this layout:
typedef struct struct_known_interfaces {
void *unknown_function_ptr;
const char *name; // ex: "STEAMAPPLIST_INTERFACE_VERSION001"
const char *family; // ex: "AppList"
struct_known_interfaces *previous_node;
};
this is a dump of the `name` field when running this function from a debugger
*/
extern const std::unordered_set<std::string> client_known_interfaces = {
"SteamAppDisableUpdate001",
"STEAMAPPLIST_INTERFACE_VERSION001",
"SteamApps001",
"STEAMAPPS_INTERFACE_VERSION001",
"STEAMAPPS_INTERFACE_VERSION002",
"STEAMAPPS_INTERFACE_VERSION003",
"STEAMAPPS_INTERFACE_VERSION004",
"STEAMAPPS_INTERFACE_VERSION005",
"STEAMAPPS_INTERFACE_VERSION006",
"STEAMAPPS_INTERFACE_VERSION007",
"STEAMAPPS_INTERFACE_VERSION008",
"STEAMAPPTICKET_INTERFACE_VERSION001",
"SteamBilling002",
"STEAMCHAT_INTERFACE_VERSION003",
"SteamController003",
"SteamController004",
"SteamController005",
"SteamController006",
"SteamController007",
"SteamController008",
"STEAMCONTROLLER_INTERFACE_VERSION",
"SteamFriends001",
"SteamFriends002",
"SteamFriends003",
"SteamFriends004",
"SteamFriends005",
"SteamFriends006",
"SteamFriends007",
"SteamFriends008",
"SteamFriends009",
"SteamFriends010",
"SteamFriends011",
"SteamFriends012",
"SteamFriends013",
"SteamFriends014",
"SteamFriends015",
"SteamFriends016",
"SteamFriends017",
"SteamGameCoordinator001",
"SteamGameServer002",
"SteamGameServer003",
"SteamGameServer004",
"SteamGameServer005",
"SteamGameServer006",
"SteamGameServer007",
"SteamGameServer008",
"SteamGameServer009",
"SteamGameServer010",
"SteamGameServer011",
"SteamGameServer012",
"SteamGameServer013",
"SteamGameServer014",
"SteamGameServer015",
"SteamGameServerStats001",
"SteamGameStats001",
"STEAMHTMLSURFACE_INTERFACE_VERSION_001",
"STEAMHTMLSURFACE_INTERFACE_VERSION_002",
"STEAMHTMLSURFACE_INTERFACE_VERSION_003",
"STEAMHTMLSURFACE_INTERFACE_VERSION_004",
"STEAMHTMLSURFACE_INTERFACE_VERSION_005",
"STEAMHTTP_INTERFACE_VERSION001",
"STEAMHTTP_INTERFACE_VERSION002",
"STEAMHTTP_INTERFACE_VERSION003",
"SteamInput001",
"SteamInput002",
"SteamInput003",
"SteamInput004",
"SteamInput005",
"SteamInput006",
"STEAMINVENTORY_INTERFACE_V001",
"STEAMINVENTORY_INTERFACE_V002",
"STEAMINVENTORY_INTERFACE_V003",
"SteamMasterServerUpdater001",
"SteamMatchGameSearch001",
"SteamMatchMaking001",
"SteamMatchMaking002",
"SteamMatchMaking003",
"SteamMatchMaking004",
"SteamMatchMaking005",
"SteamMatchMaking006",
"SteamMatchMaking007",
"SteamMatchMaking008",
"SteamMatchMaking009",
"SteamMatchMakingServers001",
"SteamMatchMakingServers002",
"STEAMMUSIC_INTERFACE_VERSION001",
"STEAMMUSICREMOTE_INTERFACE_VERSION001",
"SteamNetworking001",
"SteamNetworking002",
"SteamNetworking003",
"SteamNetworking004",
"SteamNetworking005",
"SteamNetworking006",
"SteamNetworkingMessages002",
"SteamNetworkingSockets002",
"SteamNetworkingSockets003",
"SteamNetworkingSockets004",
"SteamNetworkingSockets005",
"SteamNetworkingSockets006",
"SteamNetworkingSockets008",
"SteamNetworkingSockets009",
"SteamNetworkingSockets010",
"SteamNetworkingSockets011",
"SteamNetworkingSockets012",
"SteamNetworkingSocketsSerialized001",
"SteamNetworkingSocketsSerialized002",
"SteamNetworkingSocketsSerialized003",
"SteamNetworkingSocketsSerialized004",
"SteamNetworkingSocketsSerialized005",
"SteamNetworkingUtils001",
"SteamNetworkingUtils002",
"SteamNetworkingUtils003",
"SteamNetworkingUtils004",
"STEAMPARENTALSETTINGS_INTERFACE_VERSION001",
"SteamParties001",
"SteamParties002",
"STEAMREMOTEPLAY_INTERFACE_VERSION001",
"STEAMREMOTEPLAY_INTERFACE_VERSION002",
"STEAMREMOTESTORAGE_INTERFACE_VERSION001",
"STEAMREMOTESTORAGE_INTERFACE_VERSION002",
"STEAMREMOTESTORAGE_INTERFACE_VERSION003",
"STEAMREMOTESTORAGE_INTERFACE_VERSION004",
"STEAMREMOTESTORAGE_INTERFACE_VERSION005",
"STEAMREMOTESTORAGE_INTERFACE_VERSION006",
"STEAMREMOTESTORAGE_INTERFACE_VERSION007",
"STEAMREMOTESTORAGE_INTERFACE_VERSION008",
"STEAMREMOTESTORAGE_INTERFACE_VERSION009",
"STEAMREMOTESTORAGE_INTERFACE_VERSION010",
"STEAMREMOTESTORAGE_INTERFACE_VERSION011",
"STEAMREMOTESTORAGE_INTERFACE_VERSION012",
"STEAMREMOTESTORAGE_INTERFACE_VERSION013",
"STEAMREMOTESTORAGE_INTERFACE_VERSION014",
"STEAMREMOTESTORAGE_INTERFACE_VERSION015",
"STEAMREMOTESTORAGE_INTERFACE_VERSION016",
"STEAMSCREENSHOTS_INTERFACE_VERSION001",
"STEAMSCREENSHOTS_INTERFACE_VERSION002",
"STEAMSCREENSHOTS_INTERFACE_VERSION003",
"SteamStreamLauncher001",
"STEAMTIMELINE_INTERFACE_V001",
"STEAMTV_INTERFACE_V001",
"STEAMTV_INTERFACE_V002",
"STEAMUGC_INTERFACE_VERSION001",
"STEAMUGC_INTERFACE_VERSION002",
"STEAMUGC_INTERFACE_VERSION003",
"STEAMUGC_INTERFACE_VERSION004",
"STEAMUGC_INTERFACE_VERSION005",
"STEAMUGC_INTERFACE_VERSION006",
"STEAMUGC_INTERFACE_VERSION007",
"STEAMUGC_INTERFACE_VERSION008",
"STEAMUGC_INTERFACE_VERSION009",
"STEAMUGC_INTERFACE_VERSION010",
"STEAMUGC_INTERFACE_VERSION011",
"STEAMUGC_INTERFACE_VERSION012",
"STEAMUGC_INTERFACE_VERSION013",
"STEAMUGC_INTERFACE_VERSION014",
"STEAMUGC_INTERFACE_VERSION015",
"STEAMUGC_INTERFACE_VERSION016",
"STEAMUGC_INTERFACE_VERSION017",
"STEAMUGC_INTERFACE_VERSION018",
"STEAMUGC_INTERFACE_VERSION019",
"STEAMUGC_INTERFACE_VERSION020",
"STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001",
"SteamUser004",
"SteamUser005",
"SteamUser006",
"SteamUser007",
"SteamUser008",
"SteamUser009",
"SteamUser010",
"SteamUser011",
"SteamUser012",
"SteamUser013",
"SteamUser014",
"SteamUser015",
"SteamUser016",
"SteamUser017",
"SteamUser018",
"SteamUser019",
"SteamUser020",
"SteamUser021",
"SteamUser022",
"SteamUser023",
"STEAMUSERSTATS_INTERFACE_VERSION001",
"STEAMUSERSTATS_INTERFACE_VERSION002",
"STEAMUSERSTATS_INTERFACE_VERSION003",
"STEAMUSERSTATS_INTERFACE_VERSION004",
"STEAMUSERSTATS_INTERFACE_VERSION005",
"STEAMUSERSTATS_INTERFACE_VERSION006",
"STEAMUSERSTATS_INTERFACE_VERSION007",
"STEAMUSERSTATS_INTERFACE_VERSION008",
"STEAMUSERSTATS_INTERFACE_VERSION009",
"STEAMUSERSTATS_INTERFACE_VERSION010",
"STEAMUSERSTATS_INTERFACE_VERSION011",
"STEAMUSERSTATS_INTERFACE_VERSION012",
"SteamUtils001",
"SteamUtils002",
"SteamUtils003",
"SteamUtils004",
"SteamUtils005",
"SteamUtils006",
"SteamUtils007",
"SteamUtils008",
"SteamUtils009",
"SteamUtils010",
"STEAMVIDEO_INTERFACE_V001",
"STEAMVIDEO_INTERFACE_V002",
"STEAMVIDEO_INTERFACE_V003",
"STEAMVIDEO_INTERFACE_V004",
"STEAMVIDEO_INTERFACE_V005",
"STEAMVIDEO_INTERFACE_V006",
"STEAMVIDEO_INTERFACE_V007",
};

63
dll/dll.cpp
View File

@ -18,7 +18,6 @@
#define STEAM_API_FUNCTIONS_IMPL
#include "dll/dll.h"
#include "dll/settings_parser.h"
#include "dll/client_known_interfaces.h"
static char old_client[128] = STEAMCLIENT_INTERFACE_VERSION; //"SteamClient017";
@ -1321,7 +1320,7 @@ STEAMCLIENT_API steam_bool Steam_BGetCallback( HSteamPipe hSteamPipe, CallbackMs
STEAMCLIENT_API void Steam_FreeLastCallback( HSteamPipe hSteamPipe )
{
PRINT_DEBUG("%i", hSteamPipe);
PRINT_DEBUG("Steam_FreeLastCallback %i", hSteamPipe);
SteamAPI_ManualDispatch_FreeLastCallback( hSteamPipe );
}
@ -1331,7 +1330,7 @@ STEAMCLIENT_API steam_bool Steam_GetAPICallResult( HSteamPipe hSteamPipe, SteamA
return SteamAPI_ManualDispatch_GetAPICallResult(hSteamPipe, hSteamAPICall, pCallback, cubCallback, iCallbackExpected, pbFailed);
}
STEAMCLIENT_API void* CreateInterface( const char *pName, int *pReturnCode )
STEAMCLIENT_API void *CreateInterface( const char *pName, int *pReturnCode )
{
PRINT_DEBUG("%s %p", pName, pReturnCode);
auto ptr = create_client_interface(pName);
@ -1348,11 +1347,6 @@ STEAMCLIENT_API void Breakpad_SteamMiniDumpInit( uint32 a, const char *b, const
PRINT_DEBUG_TODO();
}
STEAMCLIENT_API void Breakpad_SteamSendMiniDump( void *a, uint32 b )
{
PRINT_DEBUG_TODO();
}
STEAMCLIENT_API void Breakpad_SteamSetAppID( uint32 unAppID )
{
PRINT_DEBUG_TODO();
@ -1375,19 +1369,19 @@ STEAMCLIENT_API void Breakpad_SteamWriteMiniDumpUsingExceptionInfoWithBuildId( i
PRINT_DEBUG(" app is writing a crash dump! [XXXXXXXXXXXXXXXXXXXXXXXXXXX]");
}
STEAMCLIENT_API steam_bool Steam_BConnected( HSteamUser hUser, HSteamPipe hSteamPipe )
STEAMCLIENT_API bool Steam_BConnected( HSteamUser hUser, HSteamPipe hSteamPipe )
{
PRINT_DEBUG_ENTRY();
return true;
}
STEAMCLIENT_API steam_bool Steam_BLoggedOn( HSteamUser hUser, HSteamPipe hSteamPipe )
STEAMCLIENT_API bool Steam_BLoggedOn( HSteamUser hUser, HSteamPipe hSteamPipe )
{
PRINT_DEBUG_ENTRY();
return true;
}
STEAMCLIENT_API steam_bool Steam_BReleaseSteamPipe( HSteamPipe hSteamPipe )
STEAMCLIENT_API bool Steam_BReleaseSteamPipe( HSteamPipe hSteamPipe )
{
PRINT_DEBUG_TODO();
return false;
@ -1417,19 +1411,19 @@ STEAMCLIENT_API HSteamPipe Steam_CreateSteamPipe()
return 0;
}
STEAMCLIENT_API steam_bool Steam_GSBLoggedOn( void *phSteamHandle )
STEAMCLIENT_API bool Steam_GSBLoggedOn( void *phSteamHandle )
{
PRINT_DEBUG_TODO();
return false;
}
STEAMCLIENT_API steam_bool Steam_GSBSecure( void *phSteamHandle)
STEAMCLIENT_API bool Steam_GSBSecure( void *phSteamHandle)
{
PRINT_DEBUG_TODO();
return false;
}
STEAMCLIENT_API steam_bool Steam_GSGetSteam2GetEncryptionKeyToSendToNewClient( void *phSteamHandle, void *pvEncryptionKey, uint32 *pcbEncryptionKey, uint32 cbMaxEncryptionKey )
STEAMCLIENT_API bool Steam_GSGetSteam2GetEncryptionKeyToSendToNewClient( void *phSteamHandle, void *pvEncryptionKey, uint32 *pcbEncryptionKey, uint32 cbMaxEncryptionKey )
{
PRINT_DEBUG_TODO();
return false;
@ -1451,37 +1445,37 @@ STEAMCLIENT_API void Steam_GSLogOn( void *phSteamHandle )
PRINT_DEBUG_TODO();
}
STEAMCLIENT_API steam_bool Steam_GSRemoveUserConnect( void *phSteamHandle, uint32 unUserID )
STEAMCLIENT_API bool Steam_GSRemoveUserConnect( void *phSteamHandle, uint32 unUserID )
{
PRINT_DEBUG_TODO();
return false;
}
STEAMCLIENT_API steam_bool Steam_GSSendSteam2UserConnect( void *phSteamHandle, uint32 unUserID, const void *pvRawKey, uint32 unKeyLen, uint32 unIPPublic, uint16 usPort, const void *pvCookie, uint32 cubCookie )
STEAMCLIENT_API bool Steam_GSSendSteam2UserConnect( void *phSteamHandle, uint32 unUserID, const void *pvRawKey, uint32 unKeyLen, uint32 unIPPublic, uint16 usPort, const void *pvCookie, uint32 cubCookie )
{
PRINT_DEBUG_TODO();
return false;
}
STEAMCLIENT_API steam_bool Steam_GSSendSteam3UserConnect( void *phSteamHandle, uint64 steamID, uint32 unIPPublic, const void *pvCookie, uint32 cubCookie )
STEAMCLIENT_API bool Steam_GSSendSteam3UserConnect( void *phSteamHandle, uint64 steamID, uint32 unIPPublic, const void *pvCookie, uint32 cubCookie )
{
PRINT_DEBUG_TODO();
return false;
}
STEAMCLIENT_API steam_bool Steam_GSSendUserDisconnect( void *phSteamHandle, uint64 ulSteamID, uint32 unUserID )
STEAMCLIENT_API bool Steam_GSSendUserDisconnect( void *phSteamHandle, uint64 ulSteamID, uint32 unUserID )
{
PRINT_DEBUG_TODO();
return false;
}
STEAMCLIENT_API steam_bool Steam_GSSendUserStatusResponse( void *phSteamHandle, uint64 ulSteamID, int nSecondsConnected, int nSecondsSinceLast )
STEAMCLIENT_API bool Steam_GSSendUserStatusResponse( void *phSteamHandle, uint64 ulSteamID, int nSecondsConnected, int nSecondsSinceLast )
{
PRINT_DEBUG_TODO();
return false;
}
STEAMCLIENT_API steam_bool Steam_GSSetServerType( void *phSteamHandle, int32 nAppIdServed, uint32 unServerFlags, uint32 unGameIP, uint32 unGamePort, const char *pchGameDir, const char *pchVersion )
STEAMCLIENT_API bool Steam_GSSetServerType( void *phSteamHandle, int32 nAppIdServed, uint32 unServerFlags, uint32 unGameIP, uint32 unGamePort, const char *pchGameDir, const char *pchVersion )
{
PRINT_DEBUG_TODO();
return false;
@ -1492,7 +1486,7 @@ STEAMCLIENT_API void Steam_GSSetSpawnCount( void *phSteamHandle, uint32 ucSpawn
PRINT_DEBUG_TODO();
}
STEAMCLIENT_API steam_bool Steam_GSUpdateStatus( void *phSteamHandle, int cPlayers, int cPlayersMax, int cBotPlayers, const char *pchServerName, const char *pchMapName )
STEAMCLIENT_API bool Steam_GSUpdateStatus( void *phSteamHandle, int cPlayers, int cPlayersMax, int cBotPlayers, const char *pchServerName, const char *pchMapName )
{
PRINT_DEBUG_TODO();
return false;
@ -1501,7 +1495,7 @@ STEAMCLIENT_API steam_bool Steam_GSUpdateStatus( void *phSteamHandle, int cPlaye
STEAMCLIENT_API void* Steam_GetGSHandle( HSteamUser hUser, HSteamPipe hSteamPipe )
{
PRINT_DEBUG_TODO();
return nullptr;
return NULL;
}
STEAMCLIENT_API int Steam_InitiateGameConnection( HSteamUser hUser, HSteamPipe hSteamPipe, void *pBlob, int cbMaxBlob, uint64 steamID, int nGameAppID, uint32 unIPServer, uint16 usPortServer, bool bSecure )
@ -1510,24 +1504,6 @@ STEAMCLIENT_API int Steam_InitiateGameConnection( HSteamUser hUser, HSteamPipe h
return 0;
}
// https://github.com/ValveSoftware/Proton/blob/962bbc4e74dde0643a6edab7c845bc628601f23f/lsteamclient/steamclient_main.c#L579-L586
STEAMCLIENT_API steam_bool Steam_IsKnownInterface( const char *pchVersion )
{
PRINT_DEBUG("'%s'", pchVersion);
// real client doesn't validate if the arg was null
if (!pchVersion) return false;
bool found = client_known_interfaces.count(pchVersion);
PRINT_DEBUG(" result=%i", (int)found);
if (!found) {
get_steam_client()->report_missing_impl(pchVersion, EMU_FUNC_NAME);
}
return found;
}
STEAMCLIENT_API void Steam_LogOff( HSteamUser hUser, HSteamPipe hSteamPipe )
{
PRINT_DEBUG_TODO();
@ -1538,13 +1514,6 @@ STEAMCLIENT_API void Steam_LogOn( HSteamUser hUser, HSteamPipe hSteamPipe, uint6
PRINT_DEBUG_TODO();
}
// https://github.com/ValveSoftware/Proton/blob/962bbc4e74dde0643a6edab7c845bc628601f23f/lsteamclient/steamclient_main.c#L588-L594
STEAMCLIENT_API void Steam_NotifyMissingInterface(HSteamPipe hSteamPipe, const char *pchVersion )
{
PRINT_DEBUG("XXXXXXXXXXXXX '%s' %i", pchVersion, hSteamPipe);
get_steam_client()->report_missing_impl(pchVersion, EMU_FUNC_NAME);
}
STEAMCLIENT_API void Steam_ReleaseThreadLocalMemory(bool thread_exit)
{
PRINT_DEBUG_TODO();

9
dll/dll/client_known_interfaces.h
View File

@ -1,9 +0,0 @@
#ifndef _CLIENT_KNOWN_INTERFACES_H_
#define _CLIENT_KNOWN_INTERFACES_H_
#include <unordered_set>
#include <string>
extern const std::unordered_set<std::string> client_known_interfaces;
#endif // _CLIENT_KNOWN_INTERFACES_H_

12
dll/dll/settings.h
View File

@ -216,7 +216,6 @@ private:
public:
constexpr const static int INVALID_IMAGE_HANDLE = 0;
constexpr const static int UNLOADED_IMAGE_HANDLE = -1;
//Depots
std::vector<DepotId_t> depots{};
@ -259,12 +258,8 @@ public:
// the stat itself is always saved regardless of that flag, only affects the achievement progress
bool save_only_higher_stat_achievement_progress = true;
// the emulator loads the achievements icons is memory mainly for `ISteamUserStats::GetAchievementIcon()`
// this defines how many icons to load each iteration when the periodic callback in `Steam_User_Stats` is triggered
// or when the app calls `SteamAPI_RunCallbacks()`
// -1 == functionality disabled
// 0 == load icons only when they're requested
// >0 == load icons in the background as mentioned above
int paginated_achievements_icons = 10;
// true means load icons lazily when they are requested, otherwise load icons as soon as the interface ISteamUserStats is initialized
bool lazy_load_achievements_icons = true;
// bypass to make SetAchievement() always return true, prevent some games from breaking
bool achievement_bypass = false;
@ -319,8 +314,6 @@ public:
bool overlay_warn_local_save = false;
//disable overlay warning for local save
bool disable_overlay_warning_local_save = false;
// should the overlay upload icons to the GPU and display them
bool overlay_upload_achs_icons_to_gpu = true;
//disable overlay warning for bad app ID (= 0)
bool disable_overlay_warning_bad_appid = false;
// disable all overlay warnings
@ -361,7 +354,6 @@ public:
CSteamID get_lobby();
bool is_offline();
void set_offline(bool offline);
uint16 get_port();
void set_port(uint16 port);

47
dll/dll/steam_app_disable_update.h
View File

@ -1,47 +0,0 @@
/* Copyright (C) 2019 Mr Goldberg
This file is part of the Goldberg Emulator
The Goldberg Emulator is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.
The Goldberg Emulator is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the Goldberg Emulator; if not, see
<http://www.gnu.org/licenses/>. */
#ifndef __INCLUDED_STEAM_APP_DISABLE_UPDATE_H__
#define __INCLUDED_STEAM_APP_DISABLE_UPDATE_H__
#include "base.h"
class Steam_App_Disable_Update:
public ISteamAppDisableUpdate
{
class Settings *settings{};
class Networking *network{};
class SteamCallResults *callback_results{};
class SteamCallBacks *callbacks{};
class RunEveryRunCB *run_every_runcb{};
static void steam_network_callback(void *object, Common_Message *msg);
static void steam_run_every_runcb(void *object);
void steam_run_callback();
void network_callback(Common_Message *msg);
public:
Steam_App_Disable_Update(class Settings *settings, class Networking *network, class SteamCallResults *callback_results, class SteamCallBacks *callbacks, class RunEveryRunCB *run_every_runcb);
~Steam_App_Disable_Update();
// probably means how many seconds to keep the updates disabled
void SetAppUpdateDisabledSecondsRemaining(int32 nSeconds);
};
#endif // __INCLUDED_STEAM_APP_DISABLE_UPDATE_H__

6
dll/dll/steam_client.h
View File

@ -56,7 +56,6 @@
#include "steam_gameserverstats.h"
#include "steam_gamestats.h"
#include "steam_timeline.h"
#include "steam_app_disable_update.h"
#include "steam_masterserver_updater.h"
#include "overlay/steam_overlay.h"
@ -141,7 +140,6 @@ public:
Steam_TV *steam_tv{};
Steam_GameStats *steam_gamestats{};
Steam_Timeline *steam_timeline{};
Steam_App_Disable_Update *steam_app_disable_update{};
Steam_GameServer *steam_gameserver{};
Steam_Utils *steam_gameserver_utils{};
@ -245,9 +243,6 @@ public:
// steam timeline
ISteamTimeline *GetISteamTimeline( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion );
// steam appp disable update
ISteamAppDisableUpdate *GetISteamAppDisableUpdate( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion );
// Deprecated. Applications should use SteamAPI_RunCallbacks() or SteamGameServer_RunCallbacks() instead.
STEAM_PRIVATE_API( void RunFrame() );
@ -343,7 +338,6 @@ public:
void DestroyAllInterfaces();
void report_missing_impl(std::string_view itf, std::string_view caller);
[[noreturn]] void report_missing_impl_and_exit(std::string_view itf, std::string_view caller);
};

3
dll/dll/steam_networking_sockets.h
View File

@ -490,6 +490,9 @@ public:
/// - k_EResultInvalidParam - nLanes is bad
EResult GetConnectionRealTimeStatus( HSteamNetConnection hConn, SteamNetConnectionRealTimeStatus_t *pStatus, int nLanes, SteamNetConnectionRealTimeLaneStatus_t *pLanes );
// based on reversing the vftable returned from original steamclient64.dll
bool GetConnectionRealTimeStatus_old( HSteamNetConnection hConn, SteamNetConnectionRealTimeStatus_t *pStatus );
/// Fetch the next available message(s) from the socket, if any.
/// Returns the number of messages returned into your array, up to nMaxMessages.
/// If the connection handle is invalid, -1 is returned.

58
dll/dll/steam_user.h
View File

@ -22,11 +22,6 @@
#include "auth.h"
class Steam_User :
public ISteamUser004,
public ISteamUser005,
public ISteamUser006,
public ISteamUser007,
public ISteamUser008,
public ISteamUser009,
public ISteamUser010,
public ISteamUser011,
@ -53,8 +48,6 @@ public ISteamUser
std::chrono::high_resolution_clock::time_point last_get_voice{};
std::string encrypted_app_ticket{};
Auth_Manager *auth_manager{};
std::map<std::string, std::string> registry{};
std::string registry_nullptr{};
public:
Steam_User(Settings *settings, Local_Storage *local_storage, class Networking *network, class SteamCallResults *callback_results, class SteamCallBacks *callbacks);
@ -64,41 +57,15 @@ public:
// this is only used internally by the API, and by a few select interfaces that support multi-user
HSteamUser GetHSteamUser();
void LogOn( CSteamID steamID );
void LogOff();
// returns true if the Steam client current has a live connection to the Steam servers.
// If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy.
// The Steam client will automatically be trying to recreate the connection as often as possible.
bool BLoggedOn();
ELogonState GetLogonState();
bool BConnected();
// returns the CSteamID of the account currently logged into the Steam client
// a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API
CSteamID GetSteamID();
bool IsVACBanned( int nGameID );
bool RequireShowVACBannedMessage( int nGameID );
void AcknowledgeVACBanning( int nGameID );
// These are dead.
int NClientGameIDAdd( int nGameID );
void RemoveClientGame( int nClientGameID );
void SetClientGameServer( int nClientGameID, uint32 unIPServer, uint16 usPortServer );
void SetSteam2Ticket( uint8 *pubTicket, int cubTicket );
void AddServerNetAddress( uint32 unIP, uint16 unPort );
bool SetEmail( const char *pchEmail );
// logon cookie - this is obsolete and never used
int GetSteamGameConnectToken( void *pBlob, int cbMaxBlob );
bool SetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, const char *pchValue );
bool GetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, char *pchValue, int cbValue );
bool SetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int iValue );
bool GetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int *piValue );
// Multiplayer Authentication functions
// InitiateGameConnection() starts the state machine for authenticating the game client with the game server
@ -119,40 +86,15 @@ public:
int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, CGameID gameID, uint32 unIPServer, uint16 usPortServer, bool bSecure );
int InitiateGameConnection( void *pBlob, int cbMaxBlob, CSteamID steamID, CGameID gameID, uint32 unIPServer, uint16 usPortServer, bool bSecure, void *pvSteam2GetEncryptionKey, int cbSteam2GetEncryptionKey );
int InitiateGameConnection( void *pBlob, int cbMaxBlob, CSteamID steamID, int nGameAppID, uint32 unIPServer, uint16 usPortServer, bool bSecure );
// notify of disconnect
// needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer );
// Legacy functions
void SetSelfAsPrimaryChatDestination();
bool IsPrimaryChatDestination();
void RequestLegacyCDKey( uint32 nAppID );
bool SendGuestPassByEmail( const char *pchEmailAccount, GID_t gidGuestPassID, bool bResending );
bool SendGuestPassByAccountID( uint32 uAccountID, GID_t gidGuestPassID, bool bResending );
bool AckGuestPass(const char *pchGuestPassCode);
bool RedeemGuestPass(const char *pchGuestPassCode);
uint32 GetGuestPassToGiveCount();
uint32 GetGuestPassToRedeemCount();
RTime32 GetGuestPassLastUpdateTime();
bool GetGuestPassToGiveInfo( uint32 nPassIndex, GID_t *pgidGuestPassID, PackageId_t *pnPackageID, RTime32 *pRTime32Created, RTime32 *pRTime32Expiration, RTime32 *pRTime32Sent, RTime32 *pRTime32Redeemed, char *pchRecipientAddress, int cRecipientAddressSize );
bool GetGuestPassToRedeemInfo( uint32 nPassIndex, GID_t *pgidGuestPassID, PackageId_t *pnPackageID, RTime32 *pRTime32Created, RTime32 *pRTime32Expiration, RTime32 *pRTime32Sent, RTime32 *pRTime32Redeemed);
bool GetGuestPassToRedeemSenderAddress( uint32 nPassIndex, char* pchSenderAddress, int cSenderAddressSize );
bool GetGuestPassToRedeemSenderName( uint32 nPassIndex, char* pchSenderName, int cSenderNameSize );
void AcknowledgeMessageByGID( const char *pchMessageGID );
bool SetLanguage( const char *pchLanguage );
// used by only a few games to track usage events
void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo);
void SetAccountName( const char *pchAccountName );
void SetPassword( const char *pchPassword );
void SetAccountCreationTime( RTime32 rt );
void RefreshSteam2Login();
// get the local storage folder for current Steam account to write application data, e.g. save games, configs etc.

7
dll/dll/steam_user_stats.h
View File

@ -70,7 +70,8 @@ public ISteamUserStats011,
public ISteamUserStats
{
public:
static constexpr const auto achievements_user_file = "achievements.json";
static constexpr auto achievements_user_file = "achievements.json";
static constexpr int UNLOADED_ACH_ICON = -1;
private:
template<typename T>
@ -94,7 +95,7 @@ private:
nlohmann::json defined_achievements{};
nlohmann::json user_achievements{};
std::vector<std::string> sorted_achievement_names{};
size_t last_loaded_ach_icon{};
bool achievements_icons_loaded = false;
std::map<std::string, int32> stats_cache_int{};
std::map<std::string, float> stats_cache_float{};
@ -212,7 +213,7 @@ public:
// specified achievement.
int GetAchievementIcon( const char *pchName );
int get_achievement_icon_handle( const std::string &ach_name, bool pbAchieved, bool force_load = false );
int get_achievement_icon_handle( const std::string &ach_name, bool pbAchieved );
std::string get_achievement_icon_name( const char *pchName, bool achieved );

1
dll/dll/steam_utils.h
View File

@ -25,7 +25,6 @@
class Steam_Utils :
public ISteamUtils001,
public ISteamUtils002,
public ISteamUtils003,
public ISteamUtils004,

22
dll/local_storage.cpp
View File

@ -17,17 +17,14 @@
#include "dll/local_storage.h"
#if defined(__WINDOWS__)
// NOTE: stb_image_write
#define STBIW_WINDOWS_UTF8
// NOTE: stb_image
#define STBI_WINDOWS_UTF8
#endif
#define STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_STATIC
#define STBI_ONLY_PNG
#define STBI_ONLY_JPEG
#if defined(__WINDOWS__)
#define STBI_WINDOWS_UTF8
#define STBIW_WINDOWS_UTF8
#endif
#include "stb/stb_image.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
@ -35,7 +32,6 @@
#include "stb/stb_image_write.h"
#define STB_IMAGE_RESIZE_IMPLEMENTATION
#define STB_IMAGE_RESIZE_STATIC
#include "stb/stb_image_resize2.h"
struct File_Data {
@ -582,7 +578,7 @@ int Local_Storage::store_file_data(std::string folder, std::string file, const c
myfile.open(std::filesystem::u8path(folder + file), std::ios::binary | std::ios::out);
if (!myfile.is_open()) return -1;
myfile.write(data, length);
int position = static_cast<int>(myfile.tellp());
int position = myfile.tellp();
myfile.close();
return position;
}
@ -670,8 +666,7 @@ int Local_Storage::get_file_data(const std::string &full_path, char *data, unsig
myfile.read (data, max_length);
myfile.close();
reset_LastError();
return static_cast<int>(myfile.gcount());
return myfile.gcount();
}
int Local_Storage::get_data(std::string folder, std::string file, char *data, unsigned int max_length, unsigned int offset)
@ -705,7 +700,7 @@ int Local_Storage::count_files(std::string folder)
folder.append(PATH_SEPARATOR);
}
return static_cast<int>(get_filenames_recursive(save_directory + appid + folder).size());
return get_filenames_recursive(save_directory + appid + folder).size();
}
bool Local_Storage::file_exists(std::string folder, std::string file)
@ -817,8 +812,7 @@ bool Local_Storage::load_json(const std::string &full_path, nlohmann::json& json
PRINT_DEBUG("Loaded json '%s' (%zu items)", full_path.c_str(), json.size());
return true;
} catch (const std::exception& e) {
const char *errorMessage = e.what();
PRINT_DEBUG("Error while parsing '%s' json error: %s", full_path.c_str(), errorMessage);
PRINT_DEBUG("Error while parsing '%s' json error: %s", full_path.c_str(), e.what());
}
} else {
PRINT_DEBUG("Couldn't open file '%s' to read json", full_path.c_str());

4
dll/network.cpp
View File

@ -110,7 +110,7 @@ static void get_broadcast_info(uint16 port)
number_broadcasts++;
if (number_broadcasts >= MAX_BROADCASTS) {
break;
return;
}
}
@ -542,8 +542,6 @@ std::set<IP_PORT> Networking::resolve_ip(std::string dns)
}
}
if (result)
freeaddrinfo(result);
return ips;
}

7
dll/settings.cpp
View File

@ -161,11 +161,6 @@ bool Settings::is_offline()
return offline;
}
void Settings::set_offline(bool offline)
{
this->offline = offline;
}
uint16 Settings::get_port()
{
return port;
@ -380,7 +375,7 @@ int Settings::add_image(const std::string &data, uint32 width, uint32 height)
Image_Data* Settings::get_image(int handle)
{
if (INVALID_IMAGE_HANDLE == handle || UNLOADED_IMAGE_HANDLE == handle) {
if (INVALID_IMAGE_HANDLE == handle) {
return nullptr;
}

22
dll/settings_parser.cpp
View File

@ -1053,8 +1053,7 @@ static void try_parse_mods_file(class Settings *settings_client, Settings *setti
PRINT_DEBUG(" workshop_item_url: '%s'", newMod.workshopItemURL.c_str());
PRINT_DEBUG(" preview_url: '%s'", newMod.previewURL.c_str());
} catch (std::exception& e) {
const char *errorMessage = e.what();
PRINT_DEBUG("MODLOADER ERROR: %s", errorMessage);
PRINT_DEBUG("MODLOADER ERROR: %s", e.what());
}
}
}
@ -1207,10 +1206,6 @@ static bool parse_branches_file(
return false;
}
// app::general::is_beta_branch
settings_client->is_beta_branch = ini.GetBoolValue("app::general", "is_beta_branch", settings_client->is_beta_branch);
settings_server->is_beta_branch = ini.GetBoolValue("app::general", "is_beta_branch", settings_server->is_beta_branch);
// app::general::branch_name
std::string selected_branch = common_helpers::string_strip(ini.GetValue("app::general", "branch_name", ""));
if (selected_branch.empty()) {
@ -1348,9 +1343,6 @@ static void parse_overlay_general_config(class Settings *settings_client, class
settings_client->disable_overlay_warning_local_save = ini.GetBoolValue("overlay::general", "disable_warning_local_save", settings_client->disable_overlay_warning_local_save);
settings_server->disable_overlay_warning_local_save = ini.GetBoolValue("overlay::general", "disable_warning_local_save", settings_server->disable_overlay_warning_local_save);
settings_client->overlay_upload_achs_icons_to_gpu = ini.GetBoolValue("overlay::general", "upload_achievements_icons_to_gpu", settings_client->overlay_upload_achs_icons_to_gpu);
settings_server->overlay_upload_achs_icons_to_gpu = ini.GetBoolValue("overlay::general", "upload_achievements_icons_to_gpu", settings_server->overlay_upload_achs_icons_to_gpu);
}
// main::misc::steam_game_stats_reports_dir
@ -1380,6 +1372,9 @@ static void parse_simple_features(class Settings *settings_client, class Setting
settings_client->disable_account_avatar = !ini.GetBoolValue("main::general", "enable_account_avatar", !settings_client->disable_account_avatar);
settings_server->disable_account_avatar = !ini.GetBoolValue("main::general", "enable_account_avatar", !settings_server->disable_account_avatar);
settings_client->is_beta_branch = ini.GetBoolValue("main::general", "is_beta_branch", settings_client->is_beta_branch);
settings_server->is_beta_branch = ini.GetBoolValue("main::general", "is_beta_branch", settings_server->is_beta_branch);
settings_client->steam_deck = ini.GetBoolValue("main::general", "steam_deck", settings_client->steam_deck);
settings_server->steam_deck = ini.GetBoolValue("main::general", "steam_deck", settings_server->steam_deck);
@ -1442,13 +1437,8 @@ static void parse_stats_features(class Settings *settings_client, class Settings
settings_client->save_only_higher_stat_achievement_progress = ini.GetBoolValue("main::stats", "save_only_higher_stat_achievement_progress", settings_client->save_only_higher_stat_achievement_progress);
settings_server->save_only_higher_stat_achievement_progress = ini.GetBoolValue("main::stats", "save_only_higher_stat_achievement_progress", settings_server->save_only_higher_stat_achievement_progress);
{
long val_client = ini.GetLongValue("main::stats", "paginated_achievements_icons", settings_client->paginated_achievements_icons);
settings_client->paginated_achievements_icons = static_cast<int>(val_client);
long val_server = ini.GetLongValue("main::stats", "paginated_achievements_icons", settings_server->paginated_achievements_icons);
settings_server->paginated_achievements_icons = static_cast<int>(val_server);
}
settings_client->lazy_load_achievements_icons = ini.GetBoolValue("main::stats", "lazy_load_achievements_icons", settings_client->lazy_load_achievements_icons);
settings_server->lazy_load_achievements_icons = ini.GetBoolValue("main::stats", "lazy_load_achievements_icons", settings_server->lazy_load_achievements_icons);
}

88
dll/steam_app_disable_update.cpp
View File

@ -1,88 +0,0 @@
/* Copyright (C) 2019 Mr Goldberg
This file is part of the Goldberg Emulator
The Goldberg Emulator is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.
The Goldberg Emulator is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the Goldberg Emulator; if not, see
<http://www.gnu.org/licenses/>. */
#include "dll/steam_app_disable_update.h"
void Steam_App_Disable_Update::steam_run_every_runcb(void *object)
{
// PRINT_DEBUG_ENTRY();
auto inst = (Steam_App_Disable_Update *)object;
inst->steam_run_callback();
}
void Steam_App_Disable_Update::steam_network_callback(void *object, Common_Message *msg)
{
// PRINT_DEBUG_ENTRY();
auto inst = (Steam_App_Disable_Update *)object;
inst->network_callback(msg);
}
Steam_App_Disable_Update::Steam_App_Disable_Update(class Settings *settings, class Networking *network, class SteamCallResults *callback_results, class SteamCallBacks *callbacks, class RunEveryRunCB *run_every_runcb)
{
this->settings = settings;
this->network = network;
this->callback_results = callback_results;
this->callbacks = callbacks;
this->run_every_runcb = run_every_runcb;
// this->network->setCallback(CALLBACK_ID_USER_STATUS, settings->get_local_steam_id(), &Steam_App_Disable_Update::steam_network_callback, this);
// this->run_every_runcb->add(&Steam_App_Disable_Update::steam_run_every_runcb, this);
}
Steam_App_Disable_Update::~Steam_App_Disable_Update()
{
// this->network->rmCallback(CALLBACK_ID_USER_STATUS, settings->get_local_steam_id(), &Steam_App_Disable_Update::steam_network_callback, this);
// this->run_every_runcb->remove(&Steam_App_Disable_Update::steam_run_every_runcb, this);
}
void Steam_App_Disable_Update::SetAppUpdateDisabledSecondsRemaining(int32 nSeconds)
{
PRINT_DEBUG_TODO();
std::lock_guard lock(global_mutex);
}
void Steam_App_Disable_Update::steam_run_callback()
{
}
void Steam_App_Disable_Update::network_callback(Common_Message *msg)
{
if (msg->has_low_level()) {
if (msg->low_level().type() == Low_Level::CONNECT) {
}
if (msg->low_level().type() == Low_Level::DISCONNECT) {
}
}
if (msg->has_networking_sockets()) {
}
}

2
dll/steam_app_ids.cpp
View File

@ -3,7 +3,7 @@
// https://developer.valvesoftware.com/wiki/Steam_Application_IDs
// https://developer.valvesoftware.com/wiki/Dedicated_Servers_List
// they're not really accurate
extern const std::map<uint32, std::string> steam_preowned_app_ids = {
const std::map<uint32, std::string> steam_preowned_app_ids = {
// { 0, "Base Goldsource Shared Binaries" },
// { 1, "Base Goldsource Shared Content" },

22
dll/steam_apps.cpp
View File

@ -84,12 +84,8 @@ bool Steam_Apps::BIsSubscribedApp( AppId_t appID )
std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (appID == 0) return false; // steam returns false
if (appID == UINT32_MAX) return true; // steam returns true
if (appID == settings->get_local_game_id().AppID() || settings->hasDLC(appID)) return true; // steam returns true
for (auto &d : settings->depots) {
if (d == appID)
return true;
}
return false;
if (appID == settings->get_local_game_id().AppID()) return true; // steam returns true
return settings->hasDLC(appID);
}
@ -116,18 +112,14 @@ uint32 Steam_Apps::GetEarliestPurchaseUnixTime( AppId_t nAppID )
std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (nAppID == 0) return 0; // steam returns 0
if (nAppID == UINT32_MAX) return 0; // steam returns 0
auto t =
// 4 days ago
startup_time
- std::chrono::hours(24 * 4);
auto duration = std::chrono::duration_cast<std::chrono::seconds>(t.time_since_epoch());
if (nAppID == settings->get_local_game_id().AppID() || settings->hasDLC(nAppID)) {
auto t =
// 4 days ago
startup_time
- std::chrono::hours(24 * 4);
auto duration = std::chrono::duration_cast<std::chrono::seconds>(t.time_since_epoch());
return (uint32)duration.count();
}
for (auto &d : settings->depots) {
if (d == nAppID)
return (uint32)duration.count();
}
//TODO ?
return 0;

2
dll/steam_client.cpp
View File

@ -124,7 +124,6 @@ Steam_Client::Steam_Client()
steam_tv = new Steam_TV(settings_client, network, callback_results_client, callbacks_client, run_every_runcb);
steam_gamestats = new Steam_GameStats(settings_client, network, callback_results_client, callbacks_client, run_every_runcb);
steam_timeline = new Steam_Timeline(settings_client, network, callback_results_client, callbacks_client, run_every_runcb);
steam_app_disable_update = new Steam_App_Disable_Update(settings_client, network, callback_results_client, callbacks_client, run_every_runcb);
// server
PRINT_DEBUG("init gameserver");
@ -206,7 +205,6 @@ Steam_Client::~Steam_Client()
DEL_INST(steam_tv);
DEL_INST(steam_gamestats);
DEL_INST(steam_timeline);
DEL_INST(steam_app_disable_update);
DEL_INST(steam_utils);
DEL_INST(steam_friends);

49
dll/steam_client_interface_getter.cpp
View File

@ -18,19 +18,6 @@
#include "dll/steam_client.h"
// retrieves the ISteamAppDisableUpdate interface associated with the handle
ISteamAppDisableUpdate *Steam_Client::GetISteamAppDisableUpdate( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
{
PRINT_DEBUG("%s", pchVersion);
if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return nullptr;
if (strcmp(pchVersion, STEAMAPPDISABLEUPDATE_INTERFACE_VERSION) == 0) {
return reinterpret_cast<ISteamAppDisableUpdate *>(static_cast<ISteamAppDisableUpdate *>(steam_app_disable_update));
}
report_missing_impl_and_exit(pchVersion, EMU_FUNC_NAME);
}
// retrieves the ISteamTimeline interface associated with the handle
ISteamTimeline *Steam_Client::GetISteamTimeline( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
{
@ -71,17 +58,7 @@ ISteamUser *Steam_Client::GetISteamUser( HSteamUser hSteamUser, HSteamPipe hStea
PRINT_DEBUG("%s", pchVersion);
if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
if (strcmp(pchVersion, "SteamUser004") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser004 *>(steam_user)); // sdk 0.99u
} else if (strcmp(pchVersion, "SteamUser005") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser005 *>(steam_user)); // sdk 0.99v
} else if (strcmp(pchVersion, "SteamUser006") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser006 *>(steam_user)); // sdk 0.99w
} else if (strcmp(pchVersion, "SteamUser007") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser007 *>(steam_user)); // sdk 0.99x
} else if (strcmp(pchVersion, "SteamUser008") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser008 *>(steam_user)); // sdk 0.99y
} else if (strcmp(pchVersion, "SteamUser009") == 0) {
if (strcmp(pchVersion, "SteamUser009") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser009 *>(steam_user));
} else if (strcmp(pchVersion, "SteamUser010") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser010 *>(steam_user));
@ -209,10 +186,7 @@ ISteamUtils *Steam_Client::GetISteamUtils( HSteamPipe hSteamPipe, const char *pc
steam_utils_temp = steam_utils;
}
if (strcmp(pchVersion, "SteamUtils001") == 0) {
return reinterpret_cast<ISteamUtils *>(static_cast<ISteamUtils001 *>(steam_utils_temp));
} else if (strcmp(pchVersion, "SteamUtils002") == 0) {
if (strcmp(pchVersion, "SteamUtils002") == 0) {
return reinterpret_cast<ISteamUtils *>(static_cast<ISteamUtils002 *>(steam_utils_temp));
} else if (strcmp(pchVersion, "SteamUtils003") == 0) {
return reinterpret_cast<ISteamUtils *>(static_cast<ISteamUtils003 *>(steam_utils_temp)); // ISteamUtils003 Not found in public Archive, must be between 1.02-1.03
@ -448,8 +422,6 @@ void *Steam_Client::GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe
return GetAppTicket(hSteamUser, hSteamPipe, pchVersion);
} else if (strstr(pchVersion, "STEAMTIMELINE_INTERFACE") == pchVersion) {
return GetISteamTimeline(hSteamUser, hSteamPipe, pchVersion);
} else if (strstr(pchVersion, "SteamAppDisableUpdate") == pchVersion) {
return GetISteamAppDisableUpdate(hSteamUser, hSteamPipe, pchVersion);
}
PRINT_DEBUG("No interface: %s", pchVersion);
@ -753,8 +725,6 @@ ISteamUGC *Steam_Client::GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamP
return reinterpret_cast<ISteamUGC *>(static_cast<ISteamUGC017 *>(steam_ugc_temp));
} else if (strcmp(pchVersion, "STEAMUGC_INTERFACE_VERSION018") == 0) {
return reinterpret_cast<ISteamUGC *>(static_cast<ISteamUGC018 *>(steam_ugc_temp));
} else if (strcmp(pchVersion, "STEAMUGC_INTERFACE_VERSION019") == 0) {
return reinterpret_cast<ISteamUGC *>(static_cast<ISteamUGC *>(steam_ugc_temp));
} else if (strcmp(pchVersion, STEAMUGC_INTERFACE_VERSION) == 0) {
return reinterpret_cast<ISteamUGC *>(static_cast<ISteamUGC *>(steam_ugc_temp));
}
@ -968,7 +938,7 @@ ISteamAppTicket *Steam_Client::GetAppTicket( HSteamUser hSteamUser, HSteamPipe h
report_missing_impl_and_exit(pchVersion, EMU_FUNC_NAME);
}
void Steam_Client::report_missing_impl(std::string_view itf, std::string_view caller)
void Steam_Client::report_missing_impl_and_exit(std::string_view itf, std::string_view caller)
{
PRINT_DEBUG("'%s' '%s'", itf.data(), caller.data());
std::lock_guard lck(global_mutex);
@ -977,27 +947,18 @@ void Steam_Client::report_missing_impl(std::string_view itf, std::string_view ca
try {
ss << "INTERFACE=" << itf << "\n";
ss << "CALLER FN=" << caller << "\n";
}
catch(...) { }
try {
if (settings_client) {
ss << "APPID=" << settings_client->get_local_game_id().AppID() << "\n";
}
}
catch(...) { }
try {
std::string time(common_helpers::get_utc_time());
if (time.size()) {
ss << "TIME=" << time << "\n";
}
ss << "--------------------\n" << std::endl;
}
catch(...) { }
try {
std::ofstream report(std::filesystem::u8path(get_full_program_path() + "EMU_MISSING_INTERFACE.txt"), std::ios::out | std::ios::app);
if (report.is_open()) {
report << ss.str();
@ -1008,10 +969,6 @@ void Steam_Client::report_missing_impl(std::string_view itf, std::string_view ca
#if defined(__WINDOWS__)
MessageBoxA(nullptr, ss.str().c_str(), "Missing interface", MB_OK);
#endif
}
void Steam_Client::report_missing_impl_and_exit(std::string_view itf, std::string_view caller)
{
report_missing_impl(itf, caller);
std::exit(0x4155149); // MISSING :)
}

2
dll/steam_matchmaking.cpp
View File

@ -1384,7 +1384,7 @@ void Steam_Matchmaking::RunCallbacks()
PRINT_DEBUG("Lobby " "%" PRIu64 " use %u", l.room_id(), use);
if (use) PUSH_BACK_IF_NOT_IN(filtered_lobbies, (uint64)l.room_id());
if (filtered_lobbies.size() >= static_cast<size_t>(filter_max_results_copy)) {
if (filtered_lobbies.size() >= filter_max_results_copy) {
PRINT_DEBUG("returning lobby search results, count=%zu", filtered_lobbies.size());
searching = false;
LobbyMatchList_t data{};

35
dll/steam_networking_sockets.cpp
View File

@ -950,6 +950,24 @@ EResult Steam_Networking_Sockets::GetConnectionRealTimeStatus( HSteamNetConnecti
return k_EResultOK;
}
// based on reversing the vftable returned from original steamclient64.dll
bool Steam_Networking_Sockets::GetConnectionRealTimeStatus_old( HSteamNetConnection hConn, SteamNetConnectionRealTimeStatus_t *pStatus )
{
PRINT_DEBUG("undocumented API, interface v10-11");
/*
...
xor r9d, r9d // int nLanes = 0
mov qword ptr ss:[rsp+0x20], 0x0 // SteamNetConnectionRealTimeLaneStatus_t *pLanes = nullptr
...
call qword ptr ds:[rax+0x80] // call GetConnectionRealTimeStatus(hConn, pStatus, nLanes, pLanes)
test eax, eax
setne al if (eax !=0) { al=1 } else { al=0 }
...
ret
*/
return GetConnectionRealTimeStatus(hConn, pStatus, 0, nullptr) != EResult::k_EResultNone;
}
/// Fetch the next available message(s) from the socket, if any.
/// Returns the number of messages returned into your array, up to nMaxMessages.
/// If the connection handle is invalid, -1 is returned.
@ -1004,19 +1022,10 @@ bool Steam_Networking_Sockets::GetConnectionInfo( HSteamNetConnection hConn, Ste
bool Steam_Networking_Sockets::GetQuickConnectionStatus( HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus *pStats )
{
PRINT_DEBUG_ENTRY();
// based on reversing the vftable returned from original steamclient64.dll
/*
...
xor r9d, r9d // int nLanes = 0
mov qword ptr ss:[rsp+0x20], 0x0 // SteamNetConnectionRealTimeLaneStatus_t *pLanes = nullptr
...
call qword ptr ds:[rax+0x80] // call GetConnectionRealTimeStatus(hConn, pStatus, nLanes, pLanes)
test eax, eax
setne al if (eax !=0) { al=1 } else { al=0 }
...
ret
*/
return GetConnectionRealTimeStatus(hConn, pStats, 0, NULL) != k_EResultNone;
if (!pStats)
return false;
return GetConnectionRealTimeStatus(hConn, pStats, 0, NULL) == k_EResultOK;
}

328
dll/steam_user.cpp
View File

@ -44,18 +44,6 @@ HSteamUser Steam_User::GetHSteamUser()
return CLIENT_HSTEAMUSER;
}
void Steam_User::LogOn( CSteamID steamID )
{
PRINT_DEBUG_ENTRY();
settings->set_offline(false);
}
void Steam_User::LogOff()
{
PRINT_DEBUG_ENTRY();
settings->set_offline(true);
}
// returns true if the Steam client current has a live connection to the Steam servers.
// If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy.
// The Steam client will automatically be trying to recreate the connection as often as possible.
@ -65,21 +53,6 @@ bool Steam_User::BLoggedOn()
return !settings->is_offline();
}
ELogonState Steam_User::GetLogonState()
{
PRINT_DEBUG_ENTRY();
if(settings->is_offline())
return (ELogonState)0;
else
return (ELogonState)4; // tested on real steam, undocumented return value
}
bool Steam_User::BConnected()
{
PRINT_DEBUG_ENTRY();
return !settings->is_offline();
}
// returns the CSteamID of the account currently logged into the Steam client
// a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API
CSteamID Steam_User::GetSteamID()
@ -90,160 +63,6 @@ CSteamID Steam_User::GetSteamID()
return id;
}
bool Steam_User::IsVACBanned( int nGameID )
{
PRINT_DEBUG_ENTRY();
return false;
}
bool Steam_User::RequireShowVACBannedMessage( int nGameID )
{
PRINT_DEBUG_ENTRY();
return false;
}
void Steam_User::AcknowledgeVACBanning( int nGameID )
{
PRINT_DEBUG_ENTRY();
}
// according to comments in sdk, "these are dead."
int Steam_User::NClientGameIDAdd( int nGameID )
{
PRINT_DEBUG_ENTRY();
return 0;
}
// according to comments in sdk, "these are dead."
void Steam_User::RemoveClientGame( int nClientGameID )
{
PRINT_DEBUG_ENTRY();
}
// according to comments in sdk, "these are dead."
void Steam_User::SetClientGameServer( int nClientGameID, uint32 unIPServer, uint16 usPortServer )
{
PRINT_DEBUG_ENTRY();
}
void Steam_User::SetSteam2Ticket( uint8 *pubTicket, int cubTicket )
{
PRINT_DEBUG_ENTRY();
}
void Steam_User::AddServerNetAddress( uint32 unIP, uint16 unPort )
{
PRINT_DEBUG_ENTRY();
}
bool Steam_User::SetEmail( const char *pchEmail )
{
PRINT_DEBUG_ENTRY();
return false;
}
// according to comments in sdk, "logon cookie - this is obsolete and never used"
int Steam_User::GetSteamGameConnectToken( void *pBlob, int cbMaxBlob )
{
PRINT_DEBUG_ENTRY();
return 0;
}
bool Steam_User::SetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, const char *pchValue )
{
PRINT_DEBUG_TODO();
if (!pchValue)
return false; // real steam crashes, so return value is assumed
if (!pchKey) // tested on real steam
{
registry.clear();
registry_nullptr = std::string(pchValue);
}
else
{
registry[std::string(pchKey)] = std::string(pchValue);
// TODO: save it to disk, because real steam can get the string when app restarts
}
return true;
}
bool Steam_User::GetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, char *pchValue, int cbValue )
{
PRINT_DEBUG_TODO();
// TODO: read data on disk, because real steam can get the string when app restarts
if (pchValue && cbValue > 0)
memset(pchValue, 0, cbValue);
std::string value{};
if(!pchKey)
{
value = registry_nullptr;
}
else
{
auto it = registry.find(std::string(pchKey));
if (it == registry.end())
return false;
value = it->second;
}
if (pchValue && cbValue > 0)
value.copy(pchValue, cbValue - 1);
return true;
}
bool Steam_User::SetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int iValue )
{
PRINT_DEBUG_TODO();
if (!pchKey) // tested on real steam
{
registry.clear();
registry_nullptr = std::to_string(iValue);
}
else
{
registry[std::string(pchKey)] = std::to_string(iValue);
// TODO: save it to disk, because real steam can get the string when app restarts
}
return true;
}
bool Steam_User::GetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int *piValue )
{
PRINT_DEBUG_TODO();
// TODO: read data on disk, because real steam can get the string when app restarts
if (piValue)
*piValue = 0;
std::string value{};
if(!pchKey)
{
value = registry_nullptr;
}
else
{
auto it = registry.find(std::string(pchKey));
if (it == registry.end())
return false;
value = it->second;
}
try
{
if (piValue)
*piValue = std::stoi(value);
}
catch(...)
{
PRINT_DEBUG("not a number"); // TODO: real steam returns a value other than 0 under this condition
}
return true;
}
// Multiplayer Authentication functions
// InitiateGameConnection() starts the state machine for authenticating the game client with the game server
@ -282,18 +101,6 @@ int Steam_User::InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSte
return InitiateGameConnection(pAuthBlob, cbMaxAuthBlob, steamIDGameServer, unIPServer, usPortServer, bSecure);
}
int Steam_User::InitiateGameConnection( void *pBlob, int cbMaxBlob, CSteamID steamID, CGameID gameID, uint32 unIPServer, uint16 usPortServer, bool bSecure, void *pvSteam2GetEncryptionKey, int cbSteam2GetEncryptionKey )
{
PRINT_DEBUG("sdk 0.99x, 0.99y");
return InitiateGameConnection(pBlob, cbMaxBlob, steamID, unIPServer, usPortServer, bSecure);
}
int Steam_User::InitiateGameConnection( void *pBlob, int cbMaxBlob, CSteamID steamID, int nGameAppID, uint32 unIPServer, uint16 usPortServer, bool bSecure )
{
PRINT_DEBUG("sdk 0.99u");
return InitiateGameConnection(pBlob, cbMaxBlob, steamID, unIPServer, usPortServer, bSecure);
}
// notify of disconnect
// needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
void Steam_User::TerminateGameConnection( uint32 unIPServer, uint16 usPortServer )
@ -303,147 +110,12 @@ void Steam_User::TerminateGameConnection( uint32 unIPServer, uint16 usPortServer
// Legacy functions
void Steam_User::SetSelfAsPrimaryChatDestination()
{
PRINT_DEBUG_TODO();
}
bool Steam_User::IsPrimaryChatDestination()
{
PRINT_DEBUG_ENTRY();
return false;
}
void Steam_User::RequestLegacyCDKey( uint32 iAppID )
{
PRINT_DEBUG_TODO();
}
bool Steam_User::SendGuestPassByEmail( const char *pchEmailAccount, GID_t gidGuestPassID, bool bResending )
{
PRINT_DEBUG_TODO();
return false;
}
bool Steam_User::SendGuestPassByAccountID( uint32 uAccountID, GID_t gidGuestPassID, bool bResending )
{
PRINT_DEBUG_TODO();
return false;
}
bool Steam_User::AckGuestPass(const char *pchGuestPassCode)
{
PRINT_DEBUG_TODO();
return false;
}
bool Steam_User::RedeemGuestPass(const char *pchGuestPassCode)
{
PRINT_DEBUG_TODO();
return false;
}
uint32 Steam_User::GetGuestPassToGiveCount()
{
PRINT_DEBUG_TODO();
return 0;
}
uint32 Steam_User::GetGuestPassToRedeemCount()
{
PRINT_DEBUG_TODO();
return 0;
}
RTime32 Steam_User::GetGuestPassLastUpdateTime()
{
PRINT_DEBUG_TODO();
return 0;
}
bool Steam_User::GetGuestPassToGiveInfo( uint32 nPassIndex, GID_t *pgidGuestPassID, PackageId_t *pnPackageID, RTime32 *pRTime32Created, RTime32 *pRTime32Expiration, RTime32 *pRTime32Sent, RTime32 *pRTime32Redeemed, char *pchRecipientAddress, int cRecipientAddressSize )
{
PRINT_DEBUG_TODO();
// TODO: pgidGuestPassID
if (pnPackageID)
*pnPackageID = 0;
if (pRTime32Created)
*pRTime32Created = 0;
if (pRTime32Expiration)
*pRTime32Expiration = 0;
if (pRTime32Sent)
*pRTime32Sent = 0;
if (pRTime32Redeemed)
*pRTime32Redeemed = 0;
if (pchRecipientAddress && cRecipientAddressSize > 0)
memset(pchRecipientAddress, 0, cRecipientAddressSize);
return false;
}
bool Steam_User::GetGuestPassToRedeemInfo( uint32 nPassIndex, GID_t *pgidGuestPassID, PackageId_t *pnPackageID, RTime32 *pRTime32Created, RTime32 *pRTime32Expiration, RTime32 *pRTime32Sent, RTime32 *pRTime32Redeemed)
{
PRINT_DEBUG_TODO();
// TODO: pgidGuestPassID
if (pnPackageID)
*pnPackageID = 0;
if (pRTime32Created)
*pRTime32Created = 0;
if (pRTime32Expiration)
*pRTime32Expiration = 0;
if (pRTime32Sent)
*pRTime32Sent = 0;
if (pRTime32Redeemed)
*pRTime32Redeemed = 0;
return false;
}
bool Steam_User::GetGuestPassToRedeemSenderAddress( uint32 nPassIndex, char* pchSenderAddress, int cSenderAddressSize )
{
PRINT_DEBUG_TODO();
return false;
}
bool Steam_User::GetGuestPassToRedeemSenderName( uint32 nPassIndex, char* pchSenderName, int cSenderNameSize )
{
PRINT_DEBUG_TODO();
if (pchSenderName && cSenderNameSize > 0)
memset(pchSenderName, 0, cSenderNameSize);
return false;
}
void Steam_User::AcknowledgeMessageByGID( const char *pchMessageGID )
{
PRINT_DEBUG_TODO();
}
bool Steam_User::SetLanguage( const char *pchLanguage )
{
PRINT_DEBUG_TODO();
// TODO: don't know what this api actually does other than returning true
return true;
}
// used by only a few games to track usage events
void Steam_User::TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo)
{
PRINT_DEBUG_TODO();
}
void Steam_User::SetAccountName( const char *pchAccountName )
{
PRINT_DEBUG_TODO();
}
void Steam_User::SetPassword( const char *pchPassword )
{
PRINT_DEBUG_TODO();
}
void Steam_User::SetAccountCreationTime( RTime32 rt )
{
PRINT_DEBUG_TODO();
}
void Steam_User::RefreshSteam2Login()
{
PRINT_DEBUG_TODO();

4
dll/steam_user_stats.cpp
View File

@ -96,8 +96,8 @@ Steam_User_Stats::Steam_User_Stats(Settings *settings, class Networking *network
it["displayName"] = get_value_for_language(it, "displayName", settings->get_language());
it["description"] = get_value_for_language(it, "description", settings->get_language());
it["icon_handle"] = Settings::UNLOADED_IMAGE_HANDLE;
it["icon_gray_handle"] = Settings::UNLOADED_IMAGE_HANDLE;
it["icon_handle"] = UNLOADED_ACH_ICON;
it["icon_gray_handle"] = UNLOADED_ACH_ICON;
}
//TODO: not sure if the sort is actually case insensitive, ach names seem to be treated by steam as case insensitive so I assume they are.

58
dll/steam_user_stats_achievements.cpp
View File

@ -80,8 +80,8 @@ void Steam_User_Stats::save_achievements()
int Steam_User_Stats::load_ach_icon(nlohmann::json &defined_ach, bool achieved)
{
const char *icon_handle_key = achieved ? "icon_handle" : "icon_gray_handle";
int current_handle = defined_ach.value(icon_handle_key, Settings::UNLOADED_IMAGE_HANDLE);
if (Settings::UNLOADED_IMAGE_HANDLE != current_handle) { // already loaded
int current_handle = defined_ach.value(icon_handle_key, UNLOADED_ACH_ICON);
if (UNLOADED_ACH_ICON != current_handle) { // already loaded
return current_handle;
}
@ -394,12 +394,7 @@ int Steam_User_Stats::GetAchievementIcon( const char *pchName )
GetAchievement(pchName, &achieved);
std::string ach_name(pchName);
// here we force load in case the game has a lot of achievements, because otherwise some games might timeout
// this somewhat defeats the purpose of background loading but a timeout is worse
int handle = get_achievement_icon_handle(ach_name, achieved, true);
if (Settings::UNLOADED_IMAGE_HANDLE == handle) { // if the background callback didn't get a chance to load this one yet
handle = Settings::INVALID_IMAGE_HANDLE;
}
int handle = get_achievement_icon_handle(ach_name, achieved);
UserAchievementIconFetched_t data{};
data.m_bAchieved = achieved ;
@ -411,10 +406,11 @@ int Steam_User_Stats::GetAchievementIcon( const char *pchName )
return handle;
}
int Steam_User_Stats::get_achievement_icon_handle( const std::string &ach_name, bool achieved, bool force_load )
int Steam_User_Stats::get_achievement_icon_handle( const std::string &ach_name, bool achieved )
{
PRINT_DEBUG("'%s', achieved=%i, force=%i", ach_name.c_str(), (int)achieved, (int)force_load);
PRINT_DEBUG("'%s', %i", ach_name.c_str(), (int)achieved);
std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (ach_name.empty()) return Settings::INVALID_IMAGE_HANDLE;
nlohmann::detail::iter_impl<nlohmann::json> it = defined_achievements.end();
try {
@ -422,20 +418,7 @@ int Steam_User_Stats::get_achievement_icon_handle( const std::string &ach_name,
} catch(...) { }
if (defined_achievements.end() == it) return Settings::INVALID_IMAGE_HANDLE;
int handle = Settings::INVALID_IMAGE_HANDLE;
if (settings->paginated_achievements_icons < 0) { // disabled functionality
handle = Settings::INVALID_IMAGE_HANDLE;
} else if (settings->paginated_achievements_icons == 0) { // load the icon only when requested
handle = load_ach_icon(*it, achieved);
} else { // depend on the periodic callback to load the icon
if (force_load) {
handle = load_ach_icon(*it, achieved);
} else {
const char *icon_handle_key = achieved ? "icon_handle" : "icon_gray_handle";
handle = it->value(icon_handle_key, Settings::UNLOADED_IMAGE_HANDLE);
}
}
int handle = load_ach_icon(*it, achieved);
PRINT_DEBUG("returned handle = %i", handle);
return handle;
}
@ -801,25 +784,16 @@ bool Steam_User_Stats::GetAchievementProgressLimits( const char *pchName, float
void Steam_User_Stats::load_achievements_icons()
{
if (last_loaded_ach_icon >= defined_achievements.size() || settings->paginated_achievements_icons <= 0) return;
#ifndef EMU_RELEASE_BUILD
auto now1 = std::chrono::high_resolution_clock::now();
#endif
int idx = 0;
for (;
idx < settings->paginated_achievements_icons && last_loaded_ach_icon < defined_achievements.size();
++idx, ++last_loaded_ach_icon) {
auto &ach = defined_achievements.at(last_loaded_ach_icon);
load_ach_icon(ach, true);
load_ach_icon(ach, false);
if (achievements_icons_loaded) return;
if (settings->lazy_load_achievements_icons) {
achievements_icons_loaded = true;
return;
}
#ifndef EMU_RELEASE_BUILD
auto now2 = std::chrono::high_resolution_clock::now();
auto dd = (unsigned)std::chrono::duration_cast<std::chrono::milliseconds>(now2 - now1).count();
PRINT_DEBUG("attempted to load %d achievements icons in %u ms", idx * 2, dd);
#endif
for (auto & defined_ach : defined_achievements) {
load_ach_icon(defined_ach, true);
load_ach_icon(defined_ach, false);
}
achievements_icons_loaded = true;
}

2
dll/steam_user_stats_leaderboard.cpp
View File

@ -186,7 +186,7 @@ unsigned int Steam_User_Stats::cache_leaderboard_ifneeded(const std::string &nam
// create a new entry in-memory and try reading the entries from disk
struct Steam_Leaderboard new_board{};
new_board.name = name;
new_board.name = common_helpers::ascii_to_lowercase(name);
new_board.sort_method = eLeaderboardSortMethod;
new_board.display_type = eLeaderboardDisplayType;
new_board.entries = load_leaderboard_entries(name);

3
dll/steam_user_stats_stats.cpp
View File

@ -582,8 +582,7 @@ bool Steam_User_Stats::ResetAllStats( bool bAchievementsToo )
// this won't actually trigger a notification, just updates the data
overlay->AddAchievementNotification(name, item, false);
} catch(const std::exception& e) {
const char *errorMessage = e.what();
PRINT_DEBUG("ERROR: %s", errorMessage);
PRINT_DEBUG("ERROR: %s", e.what());
}
}
if (needs_disk_write) save_achievements();

7
generate_credits.bat
View File

@ -2,14 +2,13 @@
setlocal EnableDelayedExpansion
cd /d "%~dp0"
set "ROOT=%cd%"
set "CREDITS_FILE=%ROOT%\CREDITS.md"
set "CREDITS_FILE=CREDITS.md"
if exist "%CREDITS_FILE%" (
del /f /q "%CREDITS_FILE%"
del /f /s /q "%CREDITS_FILE%"
)
set "GLOB=third-party libs tools\steamclient_loader sdk"
set "GLOB=third-party libs tools\steamclient_loader"
set "FILTER=SOURCE.txt"
echo:# Many thanks for these sources>> "%CREDITS_FILE%"

33
overlay_experimental/overlay/steam_overlay.h
View File

@ -71,10 +71,8 @@ struct Overlay_Achievement
bool hidden{};
bool achieved{};
uint32 unlock_time{};
std::weak_ptr<uint64_t> icon{};
std::weak_ptr<uint64_t> icon_gray{};
int icon_handle = Settings::UNLOADED_IMAGE_HANDLE;
int icon_gray_handle = Settings::UNLOADED_IMAGE_HANDLE;
std::pair< std::weak_ptr<uint64_t>, bool > icon{};
std::pair< std::weak_ptr<uint64_t>, bool > icon_gray{};
};
struct Notification
@ -101,6 +99,7 @@ struct NotificationsCoords
class Steam_Overlay
{
constexpr static const char ACH_SOUNDS_FOLDER[] = "sounds";
constexpr static const int renderer_detector_polling_ms = 100;
class Settings* settings;
@ -121,7 +120,6 @@ class Steam_Overlay
std::string show_url{};
std::vector<Overlay_Achievement> achievements{};
size_t last_loaded_ach_icon{};
bool show_overlay = false;
bool show_user_info = false;
@ -186,6 +184,12 @@ class Steam_Overlay
Steam_Overlay& operator=(Steam_Overlay const&) = delete;
Steam_Overlay& operator=(Steam_Overlay&&) = delete;
static void overlay_run_callback(void* object);
static void overlay_networking_callback(void* object, Common_Message* msg);
bool is_friend_joinable(std::pair<const Friend, friend_window_state> &f);
bool got_lobby();
bool submit_notification(
notification_type type,
const std::string &msg,
@ -209,6 +213,8 @@ class Steam_Overlay
void add_ach_progressbar(const Overlay_Achievement &ach);
ImVec4 get_notification_bg_rgba_safe();
void build_notifications(float width, float height);
// invite a single friend
void invite_friend(uint64 friend_id, class Steam_Friends* steamFriends, class Steam_Matchmaking* steamMatchmaking);
void request_renderer_detector();
void set_renderer_hook_timeout();
@ -232,26 +238,13 @@ class Steam_Overlay
bool open_overlay_hook(bool toggle);
bool try_load_ach_icon(Overlay_Achievement &ach, bool achieved, bool upload_new_icon_to_gpu);
bool try_load_ach_icon(Overlay_Achievement &ach, bool achieved);
void overlay_render_proc();
void load_next_ach_icon();
uint32 apply_global_style_color();
void render_main_window();
void steam_run_callback_update_my_lobby();
bool is_friend_joinable(std::pair<const Friend, friend_window_state> &f);
// invite a single friend
void invite_friend(uint64 friend_id, class Steam_Friends* steamFriends, class Steam_Matchmaking* steamMatchmaking);
void steam_run_callback_friends_actions();
void steam_run_callback();
void networking_msg_received(Common_Message* msg);
static void overlay_run_callback(void* object);
static void overlay_networking_callback(void* object, Common_Message* msg);
void steam_run_callback();
public:
Steam_Overlay(Settings* settings, Local_Storage *local_storage, SteamCallResults* callback_results, SteamCallBacks* callbacks, RunEveryRunCB* run_every_runcb, Networking *network);

553
overlay_experimental/steam_overlay.cpp
View File

@ -85,7 +85,23 @@ void Steam_Overlay::overlay_run_callback(void* object)
{
// PRINT_DEBUG_ENTRY();
Steam_Overlay* _this = reinterpret_cast<Steam_Overlay*>(object);
// bail immediately if we can't lock the overlay mutex, deadlock scenario:
// 1. ** the background thread locks the global mutex
// 2. -- the user opens the overlay
// 3. -- the overlay proc is triggered the next frame, locking the overlay mutex
// 4. ** the background thread locks the global mutex and runs this callback
// 5. ** this callback (already having the global mutex) attempts to lock the overlay mutex (already locked before)
// 6. ** this callback, and the background thread, are now blocked, note that the global mutex is still locked
// 7. -- in the same frame, some code in the overlay proc attempts to call a steam API which usually locks the global mutex
// sice the global mutex is still locked, the overlay proc is also blocked,
// and now both the background thread and the overlay proc and locked
// even worse, the global mutex is locked forever now
if (!_this->overlay_mutex.try_lock()) return;
_this->steam_run_callback();
_this->overlay_mutex.unlock();
}
void Steam_Overlay::overlay_networking_callback(void* object, Common_Message* msg)
@ -406,6 +422,7 @@ void Steam_Overlay::overlay_state_hook(bool ready)
// called when the user presses SHIFT + TAB
bool Steam_Overlay::open_overlay_hook(bool toggle)
{
std::lock_guard<std::recursive_mutex> lock(overlay_mutex);
if (toggle) {
ShowOverlay(!show_overlay);
}
@ -622,19 +639,16 @@ void Steam_Overlay::show_test_achievement()
ach.description = "~~~ " + ach.title + " ~~~";
ach.achieved = true;
// random add icon
if (achievements.size()) {
size_t rand_idx = common_helpers::rand_number(achievements.size() - 1);
auto &rand_ach = achievements[rand_idx];
bool achieved = rand_idx < (achievements.size() / 2);
// force upload to GPU if the pagination is request-based
try_load_ach_icon(rand_ach, achieved, settings->paginated_achievements_icons == 0);
ach.icon = rand_ach.icon;
ach.icon_gray = rand_ach.icon_gray;
try_load_ach_icon(rand_ach, achieved);
ach.icon = achieved ? rand_ach.icon : rand_ach.icon_gray;
}
// randomly add progress
bool for_progress = false;
// randomly add progress
if (common_helpers::rand_number(1000) % 2) {
for_progress = true;
uint32 progress = (uint32)(common_helpers::rand_number(500) / 10 + 50); // [50, 100]
@ -648,6 +662,41 @@ void Steam_Overlay::show_test_achievement()
notify_sound_user_achievement();
}
bool Steam_Overlay::is_friend_joinable(std::pair<const Friend, friend_window_state> &f)
{
PRINT_DEBUG("%" PRIu64 "", f.first.id());
std::lock_guard<std::recursive_mutex> lock(global_mutex);
Steam_Friends* steamFriends = get_steam_client()->steam_friends;
if (std::string(steamFriends->get_friend_rich_presence_silent((uint64)f.first.id(), "connect")).length() > 0 ) {
PRINT_DEBUG("%" PRIu64 " true (connect string)", f.first.id());
return true;
}
FriendGameInfo_t friend_game_info{};
steamFriends->GetFriendGamePlayed((uint64)f.first.id(), &friend_game_info);
if (friend_game_info.m_steamIDLobby.IsValid() && (f.second.window_state & window_state_lobby_invite)) {
PRINT_DEBUG("%" PRIu64 " true (friend in a game)", f.first.id());
return true;
}
PRINT_DEBUG("%" PRIu64 " false", f.first.id());
return false;
}
bool Steam_Overlay::got_lobby()
{
std::lock_guard<std::recursive_mutex> lock(global_mutex);
Steam_Friends* steamFriends = get_steam_client()->steam_friends;
if (std::string(steamFriends->get_friend_rich_presence_silent(settings->get_local_steam_id(), "connect")).length() > 0)
return true;
if (settings->get_lobby().IsValid())
return true;
return false;
}
void Steam_Overlay::build_friend_context_menu(Friend const& frd, friend_window_state& state)
{
if (ImGui::BeginPopupContextItem("Friends_ContextMenu", 1)) {
@ -719,21 +768,24 @@ void Steam_Overlay::build_friend_window(Friend const& frd, friend_window_state&
// Window id is after the ###, the window title is the friend name
std::string friend_window_id = std::move("###" + std::to_string(state.id));
if (ImGui::Begin((state.window_title + friend_window_id).c_str(), &show)) {
if (state.window_state & window_state_need_attention && ImGui::IsWindowFocused()) {
if (state.window_state & window_state_need_attention && ImGui::IsWindowFocused())
{
state.window_state &= ~window_state_need_attention;
}
// Fill this with the chat box and maybe the invitation
if (state.window_state & (window_state_lobby_invite | window_state_rich_invite)) {
if (state.window_state & (window_state_lobby_invite | window_state_rich_invite))
{
ImGui::LabelText("##label", translationInvitedYouToJoinTheGame[current_language], frd.name().c_str(), frd.appid());
ImGui::SameLine();
if (ImGui::Button(translationAccept[current_language])) {
if (ImGui::Button(translationAccept[current_language]))
{
state.window_state |= window_state_join;
this->has_friend_action.push(frd);
}
ImGui::SameLine();
if (ImGui::Button(translationRefuse[current_language])) {
if (ImGui::Button(translationRefuse[current_language]))
{
state.window_state &= ~(window_state_lobby_invite | window_state_rich_invite);
}
}
@ -777,12 +829,15 @@ void Steam_Overlay::build_friend_window(Friend const& frd, friend_window_state&
ImGui::SameLine();
if (ImGui::Button(translationSend[current_language])) {
if (ImGui::Button(translationSend[current_language]))
{
send_chat_msg = true;
}
if (send_chat_msg) {
if (!(state.window_state & window_state_send_message)) {
if (send_chat_msg)
{
if (!(state.window_state & window_state_send_message))
{
has_friend_action.push(frd);
state.window_state |= window_state_send_message;
}
@ -790,9 +845,8 @@ void Steam_Overlay::build_friend_window(Friend const& frd, friend_window_state&
}
// User closed the friend window
if (!show) {
if (!show)
state.window_state &= ~window_state_show;
}
ImGui::End();
}
@ -1054,7 +1108,7 @@ void Steam_Overlay::build_notifications(float width, float height)
case notification_type::achievement_progress:
case notification_type::achievement: {
const auto &ach = it->ach.value();
auto &icon_rsrc = (notification_type)it->type == notification_type::achievement
auto& [icon_rsrc, _] = (notification_type)it->type == notification_type::achievement
? ach.icon
: ach.icon_gray;
if (!icon_rsrc.expired() && ImGui::BeginTable("imgui_table", 2)) {
@ -1190,9 +1244,7 @@ void Steam_Overlay::post_achievement_notification(Overlay_Achievement &ach, bool
std::lock_guard<std::recursive_mutex> lock(overlay_mutex);
if (!Ready()) return;
bool achieved = !for_progress; // for progress notifications we want to load the gray icon
// force upload to GPU if the pagination is request-based
try_load_ach_icon(ach, achieved, settings->paginated_achievements_icons == 0);
try_load_ach_icon(ach, !for_progress); // for progress notifications we want to load the gray icon
submit_notification(
for_progress ? notification_type::achievement_progress : notification_type::achievement,
ach.title + "\n" + ach.description,
@ -1201,22 +1253,26 @@ void Steam_Overlay::post_achievement_notification(Overlay_Achievement &ach, bool
);
}
bool Steam_Overlay::try_load_ach_icon(Overlay_Achievement &ach, bool achieved, bool upload_new_icon_to_gpu)
void Steam_Overlay::invite_friend(uint64 friend_id, class Steam_Friends* steamFriends, class Steam_Matchmaking* steamMatchmaking)
{
std::string connect_str = steamFriends->get_friend_rich_presence_silent(settings->get_local_steam_id(), "connect");
if (connect_str.length() > 0) {
steamFriends->InviteUserToGame(friend_id, connect_str.c_str());
PRINT_DEBUG("sent game invitation to friend with id = %llu", friend_id);
} else if (settings->get_lobby().IsValid()) {
steamMatchmaking->InviteUserToLobby(settings->get_lobby(), friend_id);
PRINT_DEBUG("sent lobby invitation to friend with id = %llu", friend_id);
}
}
bool Steam_Overlay::try_load_ach_icon(Overlay_Achievement &ach, bool achieved)
{
if (!_renderer) return false;
if (settings->paginated_achievements_icons < 0) return false; // no icons are loaded anyway
if (!settings->overlay_upload_achs_icons_to_gpu) return false; // don't upload anything to the GPU
auto &icon_rsrc = achieved ? ach.icon : ach.icon_gray;
if (!icon_rsrc.expired()) return true;
auto& [icon_rsrc, attempted] = achieved ? ach.icon : ach.icon_gray;
if (attempted || !icon_rsrc.expired()) return true;
// icons needs to be loaded, but we're not allowed
if (!upload_new_icon_to_gpu) return false;
int &icon_handle = achieved ? ach.icon_handle : ach.icon_gray_handle;
if (Settings::UNLOADED_IMAGE_HANDLE == icon_handle) { // not loaded yet
icon_handle = get_steam_client()->steam_user_stats->get_achievement_icon_handle(ach.name, achieved);
}
const int icon_handle = get_steam_client()->steam_user_stats->get_achievement_icon_handle(ach.name, achieved);
auto image_info = settings->get_image(icon_handle);
if (image_info) {
int icon_size = static_cast<int>(settings->overlay_appearance.icon_size);
@ -1227,14 +1283,14 @@ bool Steam_Overlay::try_load_ach_icon(Overlay_Achievement &ach, bool achieved, b
PRINT_DEBUG("'%s' (result=%i)", ach.name.c_str(), (int)!icon_rsrc.expired());
}
attempted = true;
return !icon_rsrc.expired();
}
// Try to make this function as short as possible or it might affect game's fps.
void Steam_Overlay::overlay_render_proc()
{
std::lock_guard lock(overlay_mutex);
std::lock_guard<std::recursive_mutex> lock(overlay_mutex);
if (!Ready()) return;
if (show_overlay) {
@ -1246,7 +1302,6 @@ void Steam_Overlay::overlay_render_proc()
build_notifications(io.DisplaySize.x, io.DisplaySize.y);
}
load_next_ach_icon();
}
uint32 Steam_Overlay::apply_global_style_color()
@ -1425,14 +1480,13 @@ void Steam_Overlay::render_main_window()
bool achieved = x.achieved;
bool hidden = x.hidden && !achieved;
// force upload to GPU if the pagination is request-based
try_load_ach_icon(x, true, settings->paginated_achievements_icons == 0);
try_load_ach_icon(x, false, settings->paginated_achievements_icons == 0);
try_load_ach_icon(x, true);
try_load_ach_icon(x, false);
ImGui::Separator();
bool could_create_ach_table_entry = false;
if (!x.icon.expired() || !x.icon_gray.expired()) {
if (!x.icon.first.expired() || !x.icon_gray.first.expired()) {
if (ImGui::BeginTable(x.title.c_str(), 2)) {
could_create_ach_table_entry = true;
@ -1441,7 +1495,7 @@ void Steam_Overlay::render_main_window()
ImGui::TableNextRow(ImGuiTableRowFlags_None, settings->overlay_appearance.icon_size);
ImGui::TableSetColumnIndex(0);
auto &icon_rsrc = achieved ? x.icon : x.icon_gray;
auto& [icon_rsrc, _] = achieved ? x.icon : x.icon_gray;
if (!icon_rsrc.expired()) {
ImGui::Image(
(ImTextureID)*icon_rsrc.lock().get(),
@ -1579,45 +1633,162 @@ void Steam_Overlay::render_main_window()
if (style_color_stack) ImGui::PopStyleColor(style_color_stack);
ImGui::PopFont();
if (!show) {
ShowOverlay(false);
}
if (!show) ShowOverlay(false);
}
void Steam_Overlay::load_next_ach_icon()
void Steam_Overlay::networking_msg_received(Common_Message *msg)
{
// this function only works when icons pagination is active, request-based loading is not supported too (pagination=0)
if (!settings->overlay_upload_achs_icons_to_gpu || settings->paginated_achievements_icons <= 0 || achievements.empty()) return;
std::lock_guard<std::recursive_mutex> lock(overlay_mutex);
size_t linear_idx = last_loaded_ach_icon / 2; // 2 icons per achievement, 1 achieved, 1 unachieved
if (linear_idx >= achievements.size()) {
last_loaded_ach_icon = 0;
linear_idx = 0;
if (msg->has_steam_messages()) {
Friend frd;
frd.set_id(msg->source_id());
auto friend_info = friends.find(frd);
if (friend_info != friends.end()) {
Steam_Messages const& steam_message = msg->steam_messages();
// Change color to cyan for friend
friend_info->second.chat_history.append(friend_info->first.name() + ": " + steam_message.message()).append("\n", 1);
if (!(friend_info->second.window_state & window_state_show)) {
friend_info->second.window_state |= window_state_need_attention;
}
add_chat_message_notification(friend_info->first.name() + ": " + steam_message.message());
notify_sound_user_invite(friend_info->second);
}
}
#ifndef EMU_RELEASE_BUILD
auto now1 = std::chrono::high_resolution_clock::now();
#endif
auto &ach = achievements.at(linear_idx);
++last_loaded_ach_icon;
bool achieved = last_loaded_ach_icon % 2 != 0;
auto &icon_rsrc = achieved ? ach.icon : ach.icon_gray;
// always force upload to GPU in background-loading mode (pagination > 0)
bool loaded = try_load_ach_icon(ach, achieved, true);
#ifndef EMU_RELEASE_BUILD
if (loaded) {
auto now2 = std::chrono::high_resolution_clock::now();
auto dd = (unsigned)std::chrono::duration_cast<std::chrono::milliseconds>(now2 - now1).count();
PRINT_DEBUG("uploaded an achievement icon to GPU in %u ms", dd);
}
#endif
}
void Steam_Overlay::steam_run_callback()
{
if (!Ready()) return;
if (overlay_state_changed) {
overlay_state_changed = false;
GameOverlayActivated_t data{};
data.m_bActive = show_overlay;
data.m_bUserInitiated = true;
data.m_dwOverlayPID = 123;
data.m_nAppID = settings->get_local_game_id().AppID();
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
}
Steam_Friends* steamFriends = get_steam_client()->steam_friends;
Steam_Matchmaking* steamMatchmaking = get_steam_client()->steam_matchmaking;
if (save_settings) {
save_settings = false;
const char *language_text = valid_languages[current_language];
save_global_settings(get_steam_client()->local_storage, username_text, language_text);
get_steam_client()->settings_client->set_local_name(username_text);
get_steam_client()->settings_server->set_local_name(username_text);
get_steam_client()->settings_client->set_language(language_text);
get_steam_client()->settings_server->set_language(language_text);
steamFriends->resend_friend_data();
}
i_have_lobby = got_lobby();
std::for_each(friends.begin(), friends.end(), [this](std::pair<Friend const, friend_window_state> &i)
{
i.second.joinable = is_friend_joinable(i);
});
while (!has_friend_action.empty()) {
auto friend_info = friends.find(has_friend_action.front());
if (friend_info != friends.end()) {
uint64 friend_id = (uint64)friend_info->first.id();
// The user clicked on "Send"
if (friend_info->second.window_state & window_state_send_message) {
char* input = friend_info->second.chat_input;
char* end_input = input + strlen(input);
char* printable_char = std::find_if(input, end_input, [](char c) { return std::isgraph(c); });
// Check if the message contains something else than blanks
if (printable_char != end_input) {
// Handle chat send
Common_Message msg;
Steam_Messages* steam_messages = new Steam_Messages;
steam_messages->set_type(Steam_Messages::FRIEND_CHAT);
steam_messages->set_message(friend_info->second.chat_input);
msg.set_allocated_steam_messages(steam_messages);
msg.set_source_id(settings->get_local_steam_id().ConvertToUint64());
msg.set_dest_id(friend_id);
network->sendTo(&msg, true);
friend_info->second.chat_history.append(get_steam_client()->settings_client->get_local_name()).append(": ").append(input).append("\n", 1);
}
*input = 0; // Reset the input field
friend_info->second.window_state &= ~window_state_send_message;
}
// The user clicked on "Invite" (but invite all wasn't clicked)
if (friend_info->second.window_state & window_state_invite) {
invite_friend(friend_id, steamFriends, steamMatchmaking);
friend_info->second.window_state &= ~window_state_invite;
}
// The user clicked on "Join"
if (friend_info->second.window_state & window_state_join) {
std::string connect = steamFriends->get_friend_rich_presence_silent(friend_id, "connect");
// The user got a lobby invite and accepted it
if (friend_info->second.window_state & window_state_lobby_invite) {
GameLobbyJoinRequested_t data;
data.m_steamIDLobby.SetFromUint64(friend_info->second.lobbyId);
data.m_steamIDFriend.SetFromUint64(friend_id);
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
friend_info->second.window_state &= ~window_state_lobby_invite;
} else {
// The user got a rich presence invite and accepted it
if (friend_info->second.window_state & window_state_rich_invite) {
GameRichPresenceJoinRequested_t data = {};
data.m_steamIDFriend.SetFromUint64(friend_id);
strncpy(data.m_rgchConnect, friend_info->second.connect, k_cchMaxRichPresenceValueLength - 1);
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
friend_info->second.window_state &= ~window_state_rich_invite;
} else if (connect.length() > 0) {
GameRichPresenceJoinRequested_t data = {};
data.m_steamIDFriend.SetFromUint64(friend_id);
strncpy(data.m_rgchConnect, connect.c_str(), k_cchMaxRichPresenceValueLength - 1);
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
}
//Not sure about this but it fixes sonic racing transformed invites
FriendGameInfo_t friend_game_info = {};
steamFriends->GetFriendGamePlayed(friend_id, &friend_game_info);
uint64 lobby_id = friend_game_info.m_steamIDLobby.ConvertToUint64();
if (lobby_id) {
GameLobbyJoinRequested_t data;
data.m_steamIDLobby.SetFromUint64(lobby_id);
data.m_steamIDFriend.SetFromUint64(friend_id);
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
}
}
friend_info->second.window_state &= ~window_state_join;
}
}
has_friend_action.pop();
}
// if variable == true, then set it to false and return true (because state was changed) in that case
bool yes_clicked = true;
if (invite_all_friends_clicked.compare_exchange_weak(yes_clicked, false)) {
PRINT_DEBUG("Steam_Overlay will send invitations to [%zu] friends if they're using the same app", friends.size());
uint32 current_appid = settings->get_local_game_id().AppID();
for (auto &fr : friends) {
if (fr.first.appid() == current_appid) { // friend is playing the same game
uint64 friend_id = (uint64)fr.first.id();
invite_friend(friend_id, steamFriends, steamMatchmaking);
}
}
}
}
void Steam_Overlay::SetupOverlay()
{
if (settings->disable_overlay) return;
@ -1667,14 +1838,14 @@ void Steam_Overlay::UnSetupOverlay()
PRINT_DEBUG("releasing any images resources");
for (auto &ach : achievements) {
if (!ach.icon.expired()) {
_renderer->ReleaseImageResource(ach.icon);
ach.icon.reset();
if (!ach.icon.first.expired()) {
_renderer->ReleaseImageResource(ach.icon.first);
ach.icon.first.reset();
}
if (!ach.icon_gray.expired()) {
_renderer->ReleaseImageResource(ach.icon_gray);
ach.icon_gray.reset();
if (!ach.icon_gray.first.expired()) {
_renderer->ReleaseImageResource(ach.icon_gray.first);
ach.icon_gray.first.reset();
}
}
@ -1891,232 +2062,4 @@ void Steam_Overlay::AddAchievementNotification(const std::string &ach_name, nloh
}
}
// -- steam run callbacks --
void Steam_Overlay::steam_run_callback_update_my_lobby()
{
std::lock_guard<std::recursive_mutex> lock(global_mutex);
Steam_Friends* steamFriends = get_steam_client()->steam_friends;
if (std::string(steamFriends->get_friend_rich_presence_silent(settings->get_local_steam_id(), "connect")).length() > 0) {
i_have_lobby = true;
} else if (settings->get_lobby().IsValid()) {
i_have_lobby = true;
} else {
i_have_lobby = false;
}
}
bool Steam_Overlay::is_friend_joinable(std::pair<const Friend, friend_window_state> &f)
{
PRINT_DEBUG("%" PRIu64 "", f.first.id());
std::lock_guard<std::recursive_mutex> lock(global_mutex);
Steam_Friends* steamFriends = get_steam_client()->steam_friends;
if (std::string(steamFriends->get_friend_rich_presence_silent((uint64)f.first.id(), "connect")).length() > 0 ) {
PRINT_DEBUG("%" PRIu64 " true (connect string)", f.first.id());
return true;
}
FriendGameInfo_t friend_game_info{};
steamFriends->GetFriendGamePlayed((uint64)f.first.id(), &friend_game_info);
if (friend_game_info.m_steamIDLobby.IsValid() && (f.second.window_state & window_state_lobby_invite)) {
PRINT_DEBUG("%" PRIu64 " true (friend in a game)", f.first.id());
return true;
}
PRINT_DEBUG("%" PRIu64 " false", f.first.id());
return false;
}
void Steam_Overlay::invite_friend(uint64 friend_id, class Steam_Friends* steamFriends, class Steam_Matchmaking* steamMatchmaking)
{
std::string connect_str = steamFriends->get_friend_rich_presence_silent(settings->get_local_steam_id(), "connect");
if (connect_str.length() > 0) {
steamFriends->InviteUserToGame(friend_id, connect_str.c_str());
PRINT_DEBUG("sent game invitation to friend with id = %llu", friend_id);
} else if (settings->get_lobby().IsValid()) {
steamMatchmaking->InviteUserToLobby(settings->get_lobby(), friend_id);
PRINT_DEBUG("sent lobby invitation to friend with id = %llu", friend_id);
}
}
void Steam_Overlay::steam_run_callback_friends_actions()
{
Steam_Friends* steamFriends = get_steam_client()->steam_friends;
Steam_Matchmaking* steamMatchmaking = get_steam_client()->steam_matchmaking;
std::for_each(friends.begin(), friends.end(), [this](std::pair<Friend const, friend_window_state> &i) {
i.second.joinable = is_friend_joinable(i);
});
while (!has_friend_action.empty()) {
auto friend_info = friends.find(has_friend_action.front());
if (friend_info != friends.end()) {
uint64 friend_id = (uint64)friend_info->first.id();
// The user clicked on "Send"
if (friend_info->second.window_state & window_state_send_message) {
char* input = friend_info->second.chat_input;
char* end_input = input + strlen(input);
char* printable_char = std::find_if(input, end_input, [](char c) { return std::isgraph(c); });
// Check if the message contains something else than blanks
if (printable_char != end_input) {
// Handle chat send
Common_Message msg;
Steam_Messages* steam_messages = new Steam_Messages;
steam_messages->set_type(Steam_Messages::FRIEND_CHAT);
steam_messages->set_message(friend_info->second.chat_input);
msg.set_allocated_steam_messages(steam_messages);
msg.set_source_id(settings->get_local_steam_id().ConvertToUint64());
msg.set_dest_id(friend_id);
network->sendTo(&msg, true);
friend_info->second.chat_history.append(get_steam_client()->settings_client->get_local_name()).append(": ").append(input).append("\n", 1);
}
*input = 0; // Reset the input field
friend_info->second.window_state &= ~window_state_send_message;
}
// The user clicked on "Invite" (but invite all wasn't clicked)
if (friend_info->second.window_state & window_state_invite) {
invite_friend(friend_id, steamFriends, steamMatchmaking);
friend_info->second.window_state &= ~window_state_invite;
}
// The user clicked on "Join"
if (friend_info->second.window_state & window_state_join) {
std::string connect = steamFriends->get_friend_rich_presence_silent(friend_id, "connect");
// The user got a lobby invite and accepted it
if (friend_info->second.window_state & window_state_lobby_invite) {
GameLobbyJoinRequested_t data;
data.m_steamIDLobby.SetFromUint64(friend_info->second.lobbyId);
data.m_steamIDFriend.SetFromUint64(friend_id);
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
friend_info->second.window_state &= ~window_state_lobby_invite;
} else {
// The user got a rich presence invite and accepted it
if (friend_info->second.window_state & window_state_rich_invite) {
GameRichPresenceJoinRequested_t data = {};
data.m_steamIDFriend.SetFromUint64(friend_id);
strncpy(data.m_rgchConnect, friend_info->second.connect, k_cchMaxRichPresenceValueLength - 1);
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
friend_info->second.window_state &= ~window_state_rich_invite;
} else if (connect.length() > 0) {
GameRichPresenceJoinRequested_t data = {};
data.m_steamIDFriend.SetFromUint64(friend_id);
strncpy(data.m_rgchConnect, connect.c_str(), k_cchMaxRichPresenceValueLength - 1);
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
}
//Not sure about this but it fixes sonic racing transformed invites
FriendGameInfo_t friend_game_info = {};
steamFriends->GetFriendGamePlayed(friend_id, &friend_game_info);
uint64 lobby_id = friend_game_info.m_steamIDLobby.ConvertToUint64();
if (lobby_id) {
GameLobbyJoinRequested_t data;
data.m_steamIDLobby.SetFromUint64(lobby_id);
data.m_steamIDFriend.SetFromUint64(friend_id);
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
}
}
friend_info->second.window_state &= ~window_state_join;
}
}
has_friend_action.pop();
}
}
void Steam_Overlay::steam_run_callback()
{
if (!Ready()) return;
if (overlay_state_changed) {
overlay_state_changed = false;
GameOverlayActivated_t data{};
data.m_bActive = show_overlay;
data.m_bUserInitiated = true;
data.m_dwOverlayPID = 123;
data.m_nAppID = settings->get_local_game_id().AppID();
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
}
Steam_Friends* steamFriends = get_steam_client()->steam_friends;
Steam_Matchmaking* steamMatchmaking = get_steam_client()->steam_matchmaking;
if (save_settings) {
save_settings = false;
const char *language_text = valid_languages[current_language];
save_global_settings(get_steam_client()->local_storage, username_text, language_text);
get_steam_client()->settings_client->set_local_name(username_text);
get_steam_client()->settings_server->set_local_name(username_text);
get_steam_client()->settings_client->set_language(language_text);
get_steam_client()->settings_server->set_language(language_text);
steamFriends->resend_friend_data();
}
steam_run_callback_update_my_lobby();
// if variable == true, then set it to false and return true (because state was changed) in that case
bool yes_clicked = true;
if (invite_all_friends_clicked.compare_exchange_weak(yes_clicked, false)) {
PRINT_DEBUG("Steam_Overlay will send invitations to [%zu] friends if they're using the same app", friends.size());
uint32 current_appid = settings->get_local_game_id().AppID();
for (auto &fr : friends) {
if (fr.first.appid() == current_appid) { // friend is playing the same game
uint64 friend_id = (uint64)fr.first.id();
invite_friend(friend_id, steamFriends, steamMatchmaking);
}
}
}
// don't wait to lock the overlay mutex
// * the overlay proc might be active and holding the overlay mutex
// * this steam callback will be blocked, but it has the global mutex locked
// * the overlay proc tries to lock the global mutex, but since we have it, it will be blocked forever
if (overlay_mutex.try_lock()) {
if (Ready()) {
// ==============================================================
// call steam callbacks that has to change the overlay state here
// ==============================================================
steam_run_callback_friends_actions();
}
overlay_mutex.unlock();
}
}
// -- steam networking callbacks --
void Steam_Overlay::networking_msg_received(Common_Message *msg)
{
if (msg->has_steam_messages()) {
std::lock_guard<std::recursive_mutex> lock(overlay_mutex);
Friend frd;
frd.set_id(msg->source_id());
auto friend_info = friends.find(frd);
if (friend_info != friends.end()) {
Steam_Messages const& steam_message = msg->steam_messages();
// Change color to cyan for friend
friend_info->second.chat_history.append(friend_info->first.name() + ": " + steam_message.message()).append("\n", 1);
if (!(friend_info->second.window_state & window_state_show)) {
friend_info->second.window_state |= window_state_need_attention;
}
add_chat_message_notification(friend_info->first.name() + ": " + steam_message.message());
notify_sound_user_invite(friend_info->second);
}
}
}
#endif

42
package_win.bat
View File

@ -11,18 +11,17 @@ if defined NUMBER_OF_PROCESSORS (
)
)
set "ROOT=%cd%"
set "BUILD_DIR=%ROOT%\build\win"
set "OUT_DIR=%ROOT%\build\package\win"
set "BUILD_DIR=build\win"
set "OUT_DIR=build\package\win"
if "%~1" equ "" (
1>&2 echo:missing build target folder arg
1>&2 echo: missing build target folder arg
goto :end_script_with_err
)
set "TARGET_DIR=%BUILD_DIR%\%~1"
if not exist "%TARGET_DIR%\" (
1>&2 echo:build target folder wasn't found
1>&2 echo: build target folder wasn't found
goto :end_script_with_err
)
@ -35,39 +34,39 @@ set /a "PKG_EXE_MEM_PERCENT=90"
set /a "PKG_EXE_DICT_SIZE_MB=384"
set "PKG_EXE=third-party\deps\win\7za\7za.exe"
if not exist "%PKG_EXE%" (
1>&2 echo:packager wasn't found
1>&2 echo: packager wasn't found
goto :end_script_with_err
)
::::::::::::::::::::::::::::::::::::::::::
echo:// copying readmes + example files
echo: // copying readmes + example files
xcopy /y /s /e /r "%ROOT%\post_build\steam_settings.EXAMPLE\" "%TARGET_DIR%\steam_settings.EXAMPLE\"
xcopy /y /s /e /r "post_build\steam_settings.EXAMPLE\" "%TARGET_DIR%\steam_settings.EXAMPLE\"
copy /y "%ROOT%\post_build\README.release.md" "%TARGET_DIR%\"
copy /y "%ROOT%\CHANGELOG.md" "%TARGET_DIR%\"
copy /y "%ROOT%\CREDITS.md" "%TARGET_DIR%\"
copy /y "post_build\README.release.md" "%TARGET_DIR%\"
copy /y "CHANGELOG.md" "%TARGET_DIR%\"
copy /y "CREDITS.md" "%TARGET_DIR%\"
if %BUILD_DEBUG% equ 1 (
copy /y "%ROOT%\post_build\README.debug.md" "%TARGET_DIR%\"
copy /y "post_build\README.debug.md" "%TARGET_DIR%\"
)
if exist "%TARGET_DIR%\experimental\" (
copy /y "%ROOT%\post_build\README.experimental.md" "%TARGET_DIR%\experimental\"
copy /y "post_build\README.experimental.md" "%TARGET_DIR%\experimental\"
)
if exist "%TARGET_DIR%\steamclient_experimental\" (
xcopy /y /s /e /r "%ROOT%\post_build\win\ColdClientLoader.EXAMPLE\" "%TARGET_DIR%\steamclient_experimental\dll_injection.EXAMPLE\"
copy /y "%ROOT%\post_build\README.experimental_steamclient.md" "%TARGET_DIR%\steamclient_experimental\"
copy /y "%ROOT%\tools\steamclient_loader\win\ColdClientLoader.ini" "%TARGET_DIR%\steamclient_experimental\"
xcopy /y /s /e /r "post_build\win\ColdClientLoader.EXAMPLE\" "%TARGET_DIR%\steamclient_experimental\dll_injection.EXAMPLE\"
copy /y "post_build\README.experimental_steamclient.md" "%TARGET_DIR%\steamclient_experimental\"
copy /y "tools\steamclient_loader\win\ColdClientLoader.ini" "%TARGET_DIR%\steamclient_experimental\"
)
if exist "%TARGET_DIR%\tools\generate_interfaces\" (
copy /y "%ROOT%\post_build\README.generate_interfaces.md" "%TARGET_DIR%\tools\generate_interfaces\"
copy /y "post_build\README.generate_interfaces.md" "%TARGET_DIR%\tools\generate_interfaces\"
)
if exist "%TARGET_DIR%\tools\lobby_connect\" (
copy /y "%ROOT%\post_build\README.lobby_connect.md" "%TARGET_DIR%\tools\lobby_connect\"
copy /y "post_build\README.lobby_connect.md" "%TARGET_DIR%\tools\lobby_connect\"
)
::::::::::::::::::::::::::::::::::::::::::
@ -86,19 +85,22 @@ for %%A in ("%ACHIVE_DIR%") do (
)
if exist "%ACHIVE_FILE%" (
del /f /q "%ACHIVE_FILE%"
del /f /s /q "%ACHIVE_FILE%"
)
call "%PKG_EXE%" a "%ACHIVE_FILE%" "%TARGET_DIR%" -t7z -xr^^!*.lib -xr^^!*.exp -slp -ssw -mx -myx -mmemuse=p%PKG_EXE_MEM_PERCENT% -ms=on -mqs=off -mf=on -mhc+ -mhe- -m0=LZMA2:d=%PKG_EXE_DICT_SIZE_MB%m -mmt=%MAX_THREADS% -mmtf+ -mtm- -mtc- -mta- -mtr+ || (
call "%PKG_EXE%" a "%ACHIVE_FILE%" ".\%TARGET_DIR%" -t7z -xr^^!*.lib -xr^^!*.exp -slp -ssw -mx -myx -mmemuse=p%PKG_EXE_MEM_PERCENT% -ms=on -mqs=off -mf=on -mhc+ -mhe- -m0=LZMA2:d=%PKG_EXE_DICT_SIZE_MB%m -mmt=%MAX_THREADS% -mmtf+ -mtm- -mtc- -mta- -mtr+
if %errorlevel% neq 0 (
goto :end_script_with_err
)
goto :end_script
:: exit without error
:end_script
endlocal
exit /b 0
:: exit with error
:end_script_with_err
endlocal
exit /b 1

2
post_build/steam_settings.EXAMPLE/configs.app.EXAMPLE.ini
View File

@ -3,7 +3,7 @@
# ################################################################################ #
[app::general]
# by default the emu will report a 'non-beta' branch when the game calls `Steam_Apps::GetCurrentBetaName()`
# by default the emu will report a 'non-beta' branch when the game calls 'Steam_Apps::GetCurrentBetaName()'
# 1=make the game/app think we're playing on a beta branch
# default=0
is_beta_branch=0

30
post_build/steam_settings.EXAMPLE/configs.main.EXAMPLE.ini
View File

@ -20,7 +20,7 @@ enable_account_avatar=0
# default=0
immediate_gameserver_stats=0
# 1=use the proper type of the server list (internet, friends, etc...) when requested by the game
# 0=always return the type of the server list as 'LAN server'
# 0=always return the type of the server list as "LAN server"
# not recommended to enable this
# default=0
matchmaking_server_list_actual_type=0
@ -35,7 +35,7 @@ matchmaking_server_details_via_source_query=0
crash_printer_location=./path/relative/to/dll/crashes.txt
[main::stats]
# 1=prevent `Steam_User_Stats::FindLeaderboard()` from always succeeding and creating the unknown leaderboard
# 1=prevent 'Steam_User_Stats::FindLeaderboard()' from always succeeding and creating the unknown leaderboard
# not recommended to enable this
# default=0
disable_leaderboards_create_unknown=0
@ -59,16 +59,12 @@ stat_achievement_progress_functionality=1
# also has no impact on the functions which directly change stats, achievements, or achievements progress
# default=1
save_only_higher_stat_achievement_progress=1
# the emulator loads the achievements icons is memory, this is needed for APIs like `ISteamUserStats::GetAchievementIcon()` and the overlay
# the loaded icon size is controlled by [overlay::appearance] -> Icon_Size, in the file configs.overlay.ini
# this value controls how many icons to load each iteration when the periodic callback of the emu is triggered
# or when the app/game calls `SteamAPI_RunCallbacks()`
# each achievement has 2 icons, one when it's locked and another when it's unlocked, so a value of 10 means loading 20 icons
# increasing this value will cause a huge startup delay
# -1=disable this functionality (`ISteamUserStats::GetAchievementIcon()` and the overlay won't be able to use icons)
# 0=load the icon in memory only when it's requested
# default=10
paginated_achievements_icons=10
# the emulator loads the achievements icons is memory, this is needed for APIs like `ISteamUserStats::GetAchievementIcon()`
# the loaded icon size is controlled by [overlay::appearance] -> Icon_Size, in configs.overlay.ini
# 1=load icons lazily when they are requested
# 0=load icons as soon as the interface 'ISteamUserStats' is initialized
# default=1
lazy_load_achievements_icons=1
[main::connectivity]
# 1=prevent hooking OS networking APIs and allow any external requests
@ -83,11 +79,11 @@ disable_networking=0
# change the UDP/TCP port the emulator listens on, you should probably not change this because everyone needs to use the same port or you won't find yourselves on the network
# default=47584
listen_port=47584
# 1=pretend Steam is running in offline mode, mainly affects the function `ISteamUser::BLoggedOn()`
# 1=pretend Steam is running in offline mode, mainly affects the function 'ISteamUser::BLoggedOn()'
# Some games that connect to online servers might only work if the Steam emu behaves like Steam is in offline mode
# default=0
offline=0
# 1=prevent sharing stats and achievements with any game server, this also disables the interface `ISteamGameServerStats`
# 1=prevent sharing stats and achievements with any game server, this also disables the interface 'ISteamGameServerStats'
# default=0
disable_sharing_stats_with_gameserver=0
# 1=do not send server details to the server browser, only works for game servers
@ -100,7 +96,7 @@ share_leaderboards_over_network=0
# 1=prevent lobby creation in the Steam matchmaking interface
# default=0
disable_lobby_creation=0
# 1=attempt to download external HTTP(S) requests made via `Steam_HTTP::SendHTTPRequest()` inside 'steam_settings/http/' folder
# 1=attempt to download external HTTP(S) requests made via 'Steam_HTTP::SendHTTPRequest()' inside 'steam_settings/http/' folder
# make sure to:
# * set disable_lan_only=1
# * set disable_networking=0
@ -113,11 +109,11 @@ download_steamhttp_requests=0
############################################
[main::misc]
# 1=force `ISteamUserStats::SetAchievement()` to always return true
# 1=force 'ISteamUserStats::SetAchievement()' to always return true
# this is a workaround for some games that otherwise won't work
# default=0
achievements_bypass=0
# force the function `Steam_HTTP::SendHTTPRequest()` to always succeed
# force the function 'Steam_HTTP::SendHTTPRequest()' to always succeed
# default=0
force_steamhttp_success=0
# env var 'SteamOverlayGameId' breaks Steam Input when the game is added to Steam as a non-steam game

6
post_build/steam_settings.EXAMPLE/configs.overlay.EXAMPLE.ini
View File

@ -33,12 +33,6 @@ disable_warning_bad_appid=0
# 1=disable the local_save warning in the overlay
# default=0
disable_warning_local_save=0
# by default the overlay will attempt to upload the achievements icons to the GPU
# so that they are displayed, in rare cases this might keep failing and cause FPS drop
# 0=prevent the overlay from attempting to upload the icons periodically,
# in that case achievements icons won't be displayed
# default=1
upload_achievements_icons_to_gpu=1
[overlay::appearance]
# load custom TrueType font from a path, it could be absolute, or relative

55
premake5-deps.lua
View File

@ -40,22 +40,6 @@ newoption {
default = nil
}
newoption {
category = "tools",
trigger = "cmake-toolchain",
description = "Use cmake toolchain",
value = 'path/to/toolchain.cmake',
default = nil
}
newoption {
category = "tools",
trigger = "custom-extractor",
description = "Use custom extractor",
value = 'path/to/7z.exe',
default = nil
}
-- deps extraction
newoption {
category = "extract",
@ -193,16 +177,11 @@ if not third_party_dir or not os.isdir(third_party_dir) then
error('third-party dir is missing')
end
if _OPTIONS["custom-extractor"] then
extractor = _OPTIONS["custom-extractor"]
print('using custom extractor: ' .. _OPTIONS["custom-extractor"])
else
if os.host() == 'windows' then
extractor = extractor .. '.exe'
end
if not extractor or not os.isfile(extractor) then
error('extractor is missing from third-party dir. extractor: ' .. extractor)
end
if os.host() == 'windows' then
extractor = extractor .. '.exe'
end
if not extractor or not os.isfile(extractor) then
error('extractor is missing from third-party dir. extractor: ' .. extractor)
end
@ -263,13 +242,10 @@ local function cmake_build(dep_folder, is_32, extra_cmd_defs, c_flags_init, cxx_
table.insert(all_cxxflags_init, '/MT')
table.insert(all_cxxflags_init, '/D_MT')
local cmake_generator = os.getenv("CMAKE_GENERATOR") or ""
if cmake_generator == "" and os.host() == 'windows' or cmake_generator:find("Visual Studio") then
if is_32 then
cmd_gen = cmd_gen .. ' -A Win32'
else
cmd_gen = cmd_gen .. ' -A x64'
end
if is_32 then
cmd_gen = cmd_gen .. ' -A Win32'
else
cmd_gen = cmd_gen .. ' -A x64'
end
else
error("unsupported action for cmake build: " .. _ACTION)
@ -307,9 +283,6 @@ local function cmake_build(dep_folder, is_32, extra_cmd_defs, c_flags_init, cxx_
-- write toolchain file
local toolchain_file_content = ''
if _OPTIONS["cmake-toolchain"] then
toolchain_file_content='include(' .. _OPTIONS["cmake-toolchain"] .. ')\n\n'
end
if #cflags_init_str > 0 then
toolchain_file_content = toolchain_file_content .. 'set(CMAKE_C_FLAGS_INIT "' .. cflags_init_str .. '" )\n'
end
@ -388,12 +361,10 @@ end
-- chmod tools
if os.host() == "linux" then
if not _OPTIONS["custom-extractor"] then
local ok_chmod, err_chmod = os.chmod(extractor, "777")
if not ok_chmod then
error("cannot chmod: " .. err_chmod)
return
end
local ok_chmod, err_chmod = os.chmod(extractor, "777")
if not ok_chmod then
error("cannot chmod: " .. err_chmod)
return
end
if not _OPTIONS["custom-cmake"] then

12
premake5.lua
View File

@ -99,7 +99,7 @@ local function genproto()
local out_dir = 'proto_gen/' .. os_iden
if os.target() == "windows" then
if os.host() == "windows" then
protoc_exe = protoc_exe .. '.exe'
end
@ -115,7 +115,7 @@ local function genproto()
return
end
if os.target() == "linux" then
if os.host() == "linux" then
local ok_chmod, err_chmod = os.chmod(protoc_exe, "777")
if not ok_chmod then
error("Error: " .. err_chmod)
@ -123,10 +123,6 @@ local function genproto()
end
end
if (os.host() == "linux" and os.target() == "windows") then
protoc_exe = 'wine ' .. protoc_exe
end
return os.execute(protoc_exe .. ' dll/net.proto -I./dll/ --cpp_out=' .. out_dir)
end
@ -410,9 +406,7 @@ local overlay_link = {
---------
local x32_ssq_libdir = path.join(deps_dir, "libssq/build32")
local x64_ssq_libdir = path.join(deps_dir, "libssq/build64")
local cmake_generator = os.getenv("CMAKE_GENERATOR") or ""
if cmake_generator == "" and os.host() == 'windows' or cmake_generator:find("Visual Studio") then
if _ACTION and string.match(_ACTION, 'vs.+') then
x32_ssq_libdir = x32_ssq_libdir .. "/Release"
x64_ssq_libdir = x64_ssq_libdir .. "/Release"
end

22
sdk/Readme.txt
View File

@ -1,6 +1,6 @@
================================================================
Copyright © 1996-2024, Valve Corporation, All rights reserved.
Copyright © 1996-2022, Valve Corporation, All rights reserved.
================================================================
@ -8,26 +8,6 @@ Copyright © 1996-2024, Valve Corporation, All rights reserved.
Welcome to the Steamworks SDK. For documentation please see our partner
website at: http://partner.steamgames.com
----------------------------------------------------------------
v1.60 19th June 2024
----------------------------------------------------------------
General
* CSteamAPIContext has been removed. Please switch to using the Steam<interface> accessors where appropriate.
ISteamTimeline
* Added this new interface to allow games to provide information that supports the new Game Recording feature. See the [url=https://partner.steamgames.com/doc/features/timeline]Timeline[/url] documentation for more information.
ISteamUGC
* Added 64 bit m_ulTotalFilesSize to SteamUGCDetails_t which is the correct size of the content for Workshop items are larger than 2,147,483,647 bytes.
* Added GetNumSupportedGameVersions() and GetSupportedGameVersionData() which can be used to determine what game beta branches a Workshop item supports/is valid for.
* Added SetAdminQuery() to allow ISteamUGC to be used in a tools like environment for users who have the appropriate privileges for the calling appid.
ISteamApps
* Added API to allow the game to manage active beta branches.
----------------------------------------------------------------
v1.59 9th February 2024
----------------------------------------------------------------

2
sdk/source.txt
View File

@ -1,3 +1 @@
#### INFO
https://partner.steamgames.com/doc/sdk

19
sdk/steam/isteamappdisableupdate.h
View File

@ -1,19 +0,0 @@
#ifndef ISTEAMAPPDISABLEUPDATE_H
#define ISTEAMAPPDISABLEUPDATE_H
// this interface is not found in public SDK archives, it is based on reversing the returned vftable from steamclient64.dll
// requested by appid 730
class ISteamAppDisableUpdate
{
public:
// probably means how many seconds to keep the updates disabled
virtual void SetAppUpdateDisabledSecondsRemaining(int32 nSeconds) = 0;
};
#define STEAMAPPDISABLEUPDATE_INTERFACE_VERSION "SteamAppDisableUpdate001"
#endif // ISTEAMAPPDISABLEUPDATE_H

5
sdk/steam/isteamnetworkingsockets010.h
View File

@ -301,9 +301,8 @@ public:
/// Returns basic information about the high-level state of the connection.
virtual bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo_t *pInfo ) = 0;
/// Returns a small set of information about the real-time state of the connection
/// Returns false if the connection handle is invalid, or the connection has ended.
virtual bool GetQuickConnectionStatus( HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus *pStats ) = 0;
// based on reversing the vftable returned from original steamclient64.dll
virtual bool GetConnectionRealTimeStatus_old( HSteamNetConnection hConn, SteamNetConnectionRealTimeStatus_t *pStatus ) = 0;
/// Returns detailed connection stats in text format. Useful
/// for dumping to a log, etc.

5
sdk/steam/isteamnetworkingsockets011.h
View File

@ -301,9 +301,8 @@ public:
/// Returns basic information about the high-level state of the connection.
virtual bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo_t *pInfo ) = 0;
/// Returns a small set of information about the real-time state of the connection
/// Returns false if the connection handle is invalid, or the connection has ended.
virtual bool GetQuickConnectionStatus( HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus *pStats ) = 0;
// based on reversing the vftable returned from original steamclient64.dll
virtual bool GetConnectionRealTimeStatus_old( HSteamNetConnection hConn, SteamNetConnectionRealTimeStatus_t *pStatus ) = 0;
/// Returns detailed connection stats in text format. Useful
/// for dumping to a log, etc.

53
sdk/steam/isteamuser004.h
View File

@ -1,53 +0,0 @@
#ifndef ISTEAMUSER004_H
#define ISTEAMUSER004_H
#ifdef STEAM_WIN32
#pragma once
#endif
enum EConfigSubTree {
EConfigSubTree_stub
};
enum ELogonState {
ELogonState_stub
};
class ISteamUser004
{
public:
virtual HSteamUser GetHSteamUser() = 0;
virtual void LogOn( CSteamID steamID ) = 0;
virtual void LogOff() = 0;
virtual bool BLoggedOn() = 0;
virtual ELogonState GetLogonState() = 0;
virtual bool BConnected() = 0;
virtual CSteamID GetSteamID() = 0;
virtual bool IsVACBanned( int nGameID ) = 0;
virtual bool RequireShowVACBannedMessage( int nGameID ) = 0;
virtual void AcknowledgeVACBanning( int nGameID ) = 0;
// These are dead.
virtual int NClientGameIDAdd( int nGameID ) = 0;
virtual void RemoveClientGame( int nClientGameID ) = 0;
virtual void SetClientGameServer( int nClientGameID, uint32 unIPServer, uint16 usPortServer ) = 0;
virtual void SetSteam2Ticket( uint8 *pubTicket, int cubTicket ) = 0;
virtual void AddServerNetAddress( uint32 unIP, uint16 unPort ) = 0;
virtual bool SetEmail( const char *pchEmail ) = 0;
// logon cookie - this is obsolete and never used
virtual int GetSteamGameConnectToken( void *pBlob, int cbMaxBlob ) = 0;
virtual bool SetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, const char *pchValue ) = 0;
virtual bool GetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, char *pchValue, int cbValue ) = 0;
virtual bool SetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int iValue ) = 0;
virtual bool GetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int *piValue ) = 0;
virtual int InitiateGameConnection( void *pBlob, int cbMaxBlob, CSteamID steamID, int nGameAppID, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0;
virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0;
virtual void SetSelfAsPrimaryChatDestination() = 0;
virtual bool IsPrimaryChatDestination() = 0;
virtual void RequestLegacyCDKey( uint32 iAppID ) = 0;
};
#endif // ISTEAMUSER004_H

57
sdk/steam/isteamuser005.h
View File

@ -1,57 +0,0 @@
#ifndef ISTEAMUSER005_H
#define ISTEAMUSER005_H
#ifdef STEAM_WIN32
#pragma once
#endif
//-----------------------------------------------------------------------------
// Purpose: Functions for accessing and manipulating a steam account
// associated with one client instance
//-----------------------------------------------------------------------------
class ISteamUser005
{
public:
virtual HSteamUser GetHSteamUser() = 0;
virtual void LogOn( CSteamID steamID ) = 0;
virtual void LogOff() = 0;
virtual bool BLoggedOn() = 0;
virtual ELogonState GetLogonState() = 0;
virtual bool BConnected() = 0;
virtual CSteamID GetSteamID() = 0;
virtual bool IsVACBanned( int nGameID ) = 0;
virtual bool RequireShowVACBannedMessage( int nAppID ) = 0;
virtual void AcknowledgeVACBanning( int nAppID ) = 0;
virtual void SetSteam2Ticket( uint8 *pubTicket, int cubTicket ) = 0;
virtual void AddServerNetAddress( uint32 unIP, uint16 unPort ) = 0;
virtual bool SetEmail( const char *pchEmail ) = 0;
virtual bool SetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, const char *pchValue ) = 0;
virtual bool GetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, char *pchValue, int cbValue ) = 0;
virtual bool SetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int iValue ) = 0;
virtual bool GetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int *piValue ) = 0;
virtual int InitiateGameConnection( void *pBlob, int cbMaxBlob, CSteamID steamID, CGameID gameID, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0;
virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0;
virtual void SetSelfAsPrimaryChatDestination() = 0;
virtual bool IsPrimaryChatDestination() = 0;
virtual void RequestLegacyCDKey( uint32 nAppID ) = 0;
virtual bool SendGuestPassByEmail( const char *pchEmailAccount, GID_t gidGuestPassID, bool bResending ) = 0;
virtual bool SendGuestPassByAccountID( uint32 uAccountID, GID_t gidGuestPassID, bool bResending ) = 0;
virtual bool AckGuestPass(const char *pchGuestPassCode) = 0;
virtual bool RedeemGuestPass(const char *pchGuestPassCode) = 0;
virtual uint32 GetGuestPassToGiveCount() = 0;
virtual uint32 GetGuestPassToRedeemCount() = 0;
virtual RTime32 GetGuestPassLastUpdateTime() = 0;
virtual bool GetGuestPassToGiveInfo( uint32 nPassIndex, GID_t *pgidGuestPassID, PackageId_t *pnPackageID, RTime32 *pRTime32Created, RTime32 *pRTime32Expiration, RTime32 *pRTime32Sent, RTime32 *pRTime32Redeemed, char *pchRecipientAddress, int cRecipientAddressSize ) = 0;
virtual bool GetGuestPassToRedeemInfo( uint32 nPassIndex, GID_t *pgidGuestPassID, PackageId_t *pnPackageID, RTime32 *pRTime32Created, RTime32 *pRTime32Expiration, RTime32 *pRTime32Sent, RTime32 *pRTime32Redeemed) = 0;
virtual bool GetGuestPassToRedeemSenderAddress( uint32 nPassIndex, char* pchSenderAddress, int cSenderAddressSize ) = 0;
virtual bool GetGuestPassToRedeemSenderName( uint32 nPassIndex, char* pchSenderName, int cSenderNameSize ) = 0;
virtual void AcknowledgeMessageByGID( const char *pchMessageGID ) = 0;
virtual bool SetLanguage( const char *pchLanguage ) = 0;
virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0;
virtual void SetAccountName( const char *pchAccountName ) = 0;
virtual void SetPassword( const char *pchPassword ) = 0;
virtual void SetAccountCreationTime( RTime32 rt ) = 0;
};
#endif // ISTEAMUSER005_H

64
sdk/steam/isteamuser006.h
View File

@ -1,64 +0,0 @@
#ifndef ISTEAMUSER006_H
#define ISTEAMUSER006_H
#ifdef STEAM_WIN32
#pragma once
#endif
//-----------------------------------------------------------------------------
// Purpose: Functions for accessing and manipulating a steam account
// associated with one client instance
//-----------------------------------------------------------------------------
class ISteamUser006
{
public:
// returns the HSteamUser this interface represents
// this is only used internally by the API, and by a few select interfaces that support multi-user
virtual HSteamUser GetHSteamUser() = 0;
virtual void LogOn( CSteamID steamID ) = 0;
virtual void LogOff() = 0;
// returns true if the Steam client current has a live connection to the Steam servers.
// If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy.
// The Steam client will automatically be trying to recreate the connection as often as possible.
virtual bool BLoggedOn() = 0;
// returns the CSteamID of the account currently logged into the Steam client
// a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API
virtual CSteamID GetSteamID() = 0;
virtual bool SetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, const char *pchValue ) = 0;
virtual bool GetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, char *pchValue, int cbValue ) = 0;
virtual bool SetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int iValue ) = 0;
virtual bool GetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int *piValue ) = 0;
// Multiplayer Authentication functions
// InitiateGameConnection() starts the state machine for authenticating the game client with the game server
// It is the client portion of a three-way handshake between the client, the game server, and the steam servers
//
// Parameters:
// void *pAuthBlob - a pointer to empty memory that will be filled in with the authentication token.
// int cbMaxAuthBlob - the number of bytes of allocated memory in pBlob. Should be at least 2048 bytes.
// CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
// CGameID gameID - the ID of the current game. For games without mods, this is just CGameID( <appID> )
// uint32 unIPServer, uint16 usPortServer - the IP address of the game server
// bool bSecure - whether or not the client thinks that the game server is reporting itself as secure (i.e. VAC is running)
//
// return value - returns the number of bytes written to pBlob. If the return is 0, then the buffer passed in was too small, and the call has failed
// The contents of pBlob should then be sent to the game server, for it to use to complete the authentication process.
virtual int InitiateGameConnection( void *pBlob, int cbMaxBlob, CSteamID steamID, CGameID gameID, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0;
// notify of disconnect
// needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0;
// Legacy functions
// used by only a few games to track usage events
virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0;
};
#endif // ISTEAMUSER006_H

68
sdk/steam/isteamuser007.h
View File

@ -1,68 +0,0 @@
#ifndef ISTEAMUSER007_H
#define ISTEAMUSER007_H
#ifdef STEAM_WIN32
#pragma once
#endif
//-----------------------------------------------------------------------------
// Purpose: Functions for accessing and manipulating a steam account
// associated with one client instance
//-----------------------------------------------------------------------------
class ISteamUser007
{
public:
// returns the HSteamUser this interface represents
// this is only used internally by the API, and by a few select interfaces that support multi-user
virtual HSteamUser GetHSteamUser() = 0;
virtual void LogOn( CSteamID steamID ) = 0;
virtual void LogOff() = 0;
// returns true if the Steam client current has a live connection to the Steam servers.
// If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy.
// The Steam client will automatically be trying to recreate the connection as often as possible.
virtual bool BLoggedOn() = 0;
// returns the CSteamID of the account currently logged into the Steam client
// a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API
virtual CSteamID GetSteamID() = 0;
virtual bool SetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, const char *pchValue ) = 0;
virtual bool GetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, char *pchValue, int cbValue ) = 0;
virtual bool SetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int iValue ) = 0;
virtual bool GetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int *piValue ) = 0;
// Multiplayer Authentication functions
// InitiateGameConnection() starts the state machine for authenticating the game client with the game server
// It is the client portion of a three-way handshake between the client, the game server, and the steam servers
//
// Parameters:
// void *pAuthBlob - a pointer to empty memory that will be filled in with the authentication token.
// int cbMaxAuthBlob - the number of bytes of allocated memory in pBlob. Should be at least 2048 bytes.
// CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
// CGameID gameID - the ID of the current game. For games without mods, this is just CGameID( <appID> )
// uint32 unIPServer, uint16 usPortServer - the IP address of the game server
// bool bSecure - whether or not the client thinks that the game server is reporting itself as secure (i.e. VAC is running)
//
// return value - returns the number of bytes written to pBlob. If the return is 0, then the buffer passed in was too small, and the call has failed
// The contents of pBlob should then be sent to the game server, for it to use to complete the authentication process.
virtual int InitiateGameConnection( void *pBlob, int cbMaxBlob, CSteamID steamID, CGameID gameID, uint32 unIPServer, uint16 usPortServer, bool bSecure, void *pvSteam2GetEncryptionKey, int cbSteam2GetEncryptionKey ) = 0;
// notify of disconnect
// needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0;
// Legacy functions
// used by only a few games to track usage events
virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0;
// legacy authentication support - need to be called if the game server rejects the user with a 'bad ticket' error
// this is only needed under very specific circumstances
virtual void RefreshSteam2Login() = 0;
};
#endif // ISTEAMUSER007_H

60
sdk/steam/isteamuser008.h
View File

@ -1,60 +0,0 @@
#ifndef ISTEAMUSER008_H
#define ISTEAMUSER008_H
#ifdef STEAM_WIN32
#pragma once
#endif
//-----------------------------------------------------------------------------
// Purpose: Functions for accessing and manipulating a steam account
// associated with one client instance
//-----------------------------------------------------------------------------
class ISteamUser008
{
public:
// returns the HSteamUser this interface represents
// this is only used internally by the API, and by a few select interfaces that support multi-user
virtual HSteamUser GetHSteamUser() = 0;
// returns true if the Steam client current has a live connection to the Steam servers.
// If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy.
// The Steam client will automatically be trying to recreate the connection as often as possible.
virtual bool BLoggedOn() = 0;
// returns the CSteamID of the account currently logged into the Steam client
// a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API
virtual CSteamID GetSteamID() = 0;
// Multiplayer Authentication functions
// InitiateGameConnection() starts the state machine for authenticating the game client with the game server
// It is the client portion of a three-way handshake between the client, the game server, and the steam servers
//
// Parameters:
// void *pAuthBlob - a pointer to empty memory that will be filled in with the authentication token.
// int cbMaxAuthBlob - the number of bytes of allocated memory in pBlob. Should be at least 2048 bytes.
// CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
// CGameID gameID - the ID of the current game. For games without mods, this is just CGameID( <appID> )
// uint32 unIPServer, uint16 usPortServer - the IP address of the game server
// bool bSecure - whether or not the client thinks that the game server is reporting itself as secure (i.e. VAC is running)
//
// return value - returns the number of bytes written to pBlob. If the return is 0, then the buffer passed in was too small, and the call has failed
// The contents of pBlob should then be sent to the game server, for it to use to complete the authentication process.
virtual int InitiateGameConnection( void *pBlob, int cbMaxBlob, CSteamID steamID, CGameID gameID, uint32 unIPServer, uint16 usPortServer, bool bSecure, void *pvSteam2GetEncryptionKey, int cbSteam2GetEncryptionKey ) = 0;
// notify of disconnect
// needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0;
// Legacy functions
// used by only a few games to track usage events
virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0;
// legacy authentication support - need to be called if the game server rejects the user with a 'bad ticket' error
// this is only needed under very specific circumstances
virtual void RefreshSteam2Login() = 0;
};
#endif // ISTEAMUSER008_H

34
sdk/steam/isteamutils001.h
View File

@ -1,34 +0,0 @@
#ifndef ISTEAMUTILS001_H
#define ISTEAMUTILS001_H
#ifdef STEAM_WIN32
#pragma once
#endif
class ISteamUtils001
{
public:
// return the number of seconds since the user
virtual uint32 GetSecondsSinceAppActive() = 0;
virtual uint32 GetSecondsSinceComputerActive() = 0;
// the universe this client is connecting to
virtual EUniverse GetConnectedUniverse() = 0;
// Steam server time - in PST, number of seconds since January 1, 1970 (i.e unix time)
virtual uint32 GetServerRealTime() = 0;
// returns the 2 digit ISO 3166-1-alpha-2 format country code this client is running in (as looked up via an IP-to-location database)
// e.g "US" or "UK".
virtual const char *GetIPCountry() = 0;
// returns true if the image exists, and valid sizes were filled out
virtual bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight ) = 0;
// returns true if the image exists, and the buffer was successfully filled out
// results are returned in RGBA format
// the destination buffer size should be 4 * height * width * sizeof(char)
virtual bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize ) = 0;
};
#endif // ISTEAMUTILS001_H

7
sdk/steam/steam_api.h
View File

@ -21,7 +21,6 @@
#include "steam_api_common.h"
// All of the interfaces
#include "isteamappdisableupdate.h"
#include "isteamclient.h"
#include "isteamclient007.h"
#include "isteamclient008.h"
@ -38,11 +37,6 @@
#include "isteamclient019.h"
#include "isteamclient020.h"
#include "isteamuser.h"
#include "isteamuser004.h"
#include "isteamuser005.h"
#include "isteamuser006.h"
#include "isteamuser007.h"
#include "isteamuser008.h"
#include "isteamuser009.h"
#include "isteamuser010.h"
#include "isteamuser011.h"
@ -73,7 +67,6 @@
#include "isteamfriends015.h"
#include "isteamfriends016.h"
#include "isteamutils.h"
#include "isteamutils001.h"
#include "isteamutils002.h"
#include "isteamutils003.h"
#include "isteamutils004.h"

13
steamclient/steamclient.cpp
View File

@ -1,21 +1,18 @@
//#include "dll.h"
#define WIN32_LEAN_AND_MEAN
// #include "dll.h"
#include "Windows.h"
#ifdef _WIN64
#define DLL_NAME "steam_api64.dll"
#else
#define DLL_NAME "steam_api.dll"
#endif
extern "C" __declspec(dllexport) void *CreateInterface(const char *pName, int *pReturnCode)
extern "C" __declspec( dllexport ) void *CreateInterface( const char *pName, int *pReturnCode )
{
// PRINT_DEBUG("%s", pName);
//PRINT_DEBUG("%s", pName);
HMODULE steam_api = LoadLibraryA(DLL_NAME);
void *(__stdcall * create_interface)(const char *) = reinterpret_cast<void *(__stdcall *)(const char *)>(GetProcAddress(steam_api, "SteamInternal_CreateInterface"));
void *(__stdcall* create_interface)(const char*) = (void * (__stdcall *)(const char*))GetProcAddress(steam_api, "SteamInternal_CreateInterface");
return create_interface(pName);
}

2
third-party/build/win vendored

@ -1 +1 @@
Subproject commit 6cf0418a1973e43abc7a34bdf447e4305f4a235f
Subproject commit c8c5f528a1a90e7ba786990aa5176a389aae0ec9

BIN
tools/generate_emu_config/_DEFAULT/0/steam_api.7z Normal file
View File

Binary file not shown.

BIN
tools/generate_emu_config/_DEFAULT/0/steam_api.dll Normal file
View File

Binary file not shown.

BIN
tools/generate_emu_config/_DEFAULT/0/steam_api64.7z Normal file
View File

Binary file not shown.

BIN
tools/generate_emu_config/_DEFAULT/0/steam_api64.dll Normal file
View File

Binary file not shown.

211
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/generate_interfaces.au3
View File

@ -1,211 +0,0 @@
#NoTrayIcon
#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_Outfile_type=a3x
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****
#include <File.au3>
; ARC_NAME
$arc_generate_interfaces = IniRead(@ScriptDir & "\" & StringTrimRight(@ScriptName, 4) & ".ini", "ARC_NAME", "generate_interfaces", "generate_interfaces.7z")
; EXE_PATH
$generate_interfaces_release = IniRead(@ScriptDir & "\" & StringTrimRight(@ScriptName, 4) & ".ini", "EXE_PATH", "generate_interfaces_release", "generate_interfaces.exe")
$generate_interfaces64_release = IniRead(@ScriptDir & "\" & StringTrimRight(@ScriptName, 4) & ".ini", "EXE_PATH", "generate_interfaces64_release", "generate_interfaces64.exe")
$generate_interfaces_7z = @ScriptDir & '\steam_misc\tools\generate_interfaces\' & $arc_generate_interfaces
$generate_interfaces_dst = @ScriptDir & '\steam_misc\tools\generate_interfaces'
$generate_interfaces_exe = ''
Switch @OSArch
Case 'X64'
$generate_interfaces_exe = StringTrimLeft($generate_interfaces64_release, StringInStr($generate_interfaces64_release, "\", 0, -1)) ; generate_interfaces64.exe
If Not FileExists(@ScriptDir & '\steam_misc\tools\generate_interfaces\' & StringTrimLeft($generate_interfaces64_release, StringInStr($generate_interfaces64_release, "\", 0, -1))) Then
ShellExecuteWait(@ScriptDir & "\steam_misc\tools\7za\7za.exe", 'x "' & $generate_interfaces_7z & '" -o"' & $generate_interfaces_dst & '" -aoa', "", "", @SW_HIDE)
EndIf
Case 'X86'
$generate_interfaces_exe = StringTrimLeft($generate_interfaces_release, StringInStr($generate_interfaces_release, "\", 0, -1)) ; generate_interfaces.exe
If Not FileExists(@ScriptDir & '\steam_misc\tools\generate_interfaces\' & StringTrimLeft($generate_interfaces_release, StringInStr($generate_interfaces_release, "\", 0, -1))) Then
ShellExecuteWait(@ScriptDir & "\steam_misc\tools\7za\7za.exe", 'x "' & $generate_interfaces_7z & '" -o"' & $generate_interfaces_dst & '" -aoa', "", "", @SW_HIDE)
EndIf
Case Else
$generate_interfaces_exe = StringTrimLeft($generate_interfaces64_release, StringInStr($generate_interfaces64_release, "\", 0, -1)) ; generate_interfaces64.exe
If Not FileExists(@ScriptDir & '\steam_misc\tools\generate_interfaces\' & StringTrimLeft($generate_interfaces64_release, StringInStr($generate_interfaces64_release, "\", 0, -1))) Then
ShellExecuteWait(@ScriptDir & "\steam_misc\tools\7za\7za.exe", 'x "' & $generate_interfaces_7z & '" -o"' & $generate_interfaces_dst & '" -aoa', "", "", @SW_HIDE)
EndIf
EndSwitch
If Not FileExists(@ScriptDir & '\steam_api.dll') Then FileDelete(@ScriptDir & '\steam_misc\tools\generate_interfaces\' & StringTrimLeft($generate_interfaces_release, StringInStr($generate_interfaces_release, "\", 0, -1)))
If Not FileExists(@ScriptDir & '\steam_api64.dll') Then FileDelete(@ScriptDir & '\steam_misc\tools\generate_interfaces\' & StringTrimLeft($generate_interfaces64_release, StringInStr($generate_interfaces64_release, "\", 0, -1)))
Switch @OSArch
Case 'X64'
If Not FileExists(@ScriptDir & '\steam_misc\tools\generate_interfaces\' & StringTrimLeft($generate_interfaces64_release, StringInStr($generate_interfaces64_release, "\", 0, -1))) Then
$generate_interfaces_exe = StringTrimLeft($generate_interfaces_release, StringInStr($generate_interfaces_release, "\", 0, -1))
EndIf
Case 'X86'
If Not FileExists(@ScriptDir & '\steam_misc\tools\generate_interfaces\' & StringTrimLeft($generate_interfaces_release, StringInStr($generate_interfaces_release, "\", 0, -1))) Then
$generate_interfaces_exe = StringTrimLeft($generate_interfaces64_release, StringInStr($generate_interfaces64_release, "\", 0, -1))
EndIf
Case Else
If Not FileExists(@ScriptDir & '\steam_misc\tools\generate_interfaces\' & StringTrimLeft($generate_interfaces64_release, StringInStr($generate_interfaces64_release, "\", 0, -1))) Then
$generate_interfaces_exe = StringTrimLeft($generate_interfaces_release, StringInStr($generate_interfaces_release, "\", 0, -1))
EndIf
EndSwitch
If FileExists(@ScriptDir & '\valve_api.dll') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\valve_api.dll.bak' & '"', @ScriptDir, @SW_HIDE)
EndIf
If FileExists(@ScriptDir & '\steam_api.dll.bak') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api.dll.bak' & '"', @ScriptDir, @SW_HIDE)
ElseIf FileExists(@ScriptDir & '\steam_api.dll.org') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api.dll.org' & '"', @ScriptDir, @SW_HIDE)
ElseIf FileExists(@ScriptDir & '\steam_api.bak') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api.bak' & '"', @ScriptDir, @SW_HIDE)
ElseIf FileExists(@ScriptDir & '\steam_api.org') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api.org' & '"', @ScriptDir, @SW_HIDE)
ElseIf FileExists(@ScriptDir & '\steam_api_orig.dll') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api_orig.dll' & '"', @ScriptDir, @SW_HIDE)
ElseIf FileExists(@ScriptDir & '\steam_api_legit.dll') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api_legit.dll' & '"', @ScriptDir, @SW_HIDE)
#ElseIf FileExists(@ScriptDir & '\steam_api.dll') Then
#RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api.dll' & '"', @ScriptDir, @SW_HIDE)
EndIf
If FileExists(@ScriptDir & '\valve_api64.dll') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\valve_api64.dll.bak' & '"', @ScriptDir, @SW_HIDE)
EndIf
If FileExists(@ScriptDir & '\steam_api64.dll.bak') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api64.dll.bak' & '"', @ScriptDir, @SW_HIDE)
ElseIf FileExists(@ScriptDir & '\steam_api64.dll.org') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api64.dll.org' & '"', @ScriptDir, @SW_HIDE)
ElseIf FileExists(@ScriptDir & '\steam_api64.bak') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api64.bak' & '"', @ScriptDir, @SW_HIDE)
ElseIf FileExists(@ScriptDir & '\steam_api64.org') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api64.org' & '"', @ScriptDir, @SW_HIDE)
ElseIf FileExists(@ScriptDir & '\steam_api64_orig.dll') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe &' ' & '"' & @ScriptDir & '\steam_api64_orig.dll' & '"', @ScriptDir, @SW_HIDE)
ElseIf FileExists(@ScriptDir & '\steam_api64_legit.dll') Then
RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe &' ' & '"' & @ScriptDir & '\steam_api64_legit.dll' & '"', @ScriptDir, @SW_HIDE)
#ElseIf FileExists(@ScriptDir & '\steam_api64.dll') Then
#RunWait($generate_interfaces_dst & '\' & $generate_interfaces_exe & ' ' & '"' & @ScriptDir & '\steam_api64.dll' & '"', @ScriptDir, @SW_HIDE)
EndIf
FileMove(@ScriptDir & '\steam_interfaces.txt', @ScriptDir & '\steam_settings\steam_interfaces.txt', 9)
FileCopy(@ScriptDir & '\steam_settings\steam_interfaces.txt', @ScriptDir & '\steam_settings\steam_interfaces.ini', 9)
$hFile=FileOpen(@ScriptDir & '\steam_settings\steam_interfaces.ini',0)
$sOld=FileRead($hFile)
FileClose($hFile)
$hFile=FileOpen(@ScriptDir & '\steam_settings\steam_interfaces.ini',2)
$sNew='[steam_interfaces]' & @CRLF & $sOld
FileWrite($hFile,$sNew)
FileClose($hFile)
$interfaces_ini = @ScriptDir & '\steam_settings\steam_interfaces.ini'
$codex_ini = @ScriptDir & '\steam_misc\extra_crk\CODEX\steam_emu.ini'
_AddInterfaces($codex_ini)
$rune_ini = @ScriptDir & '\steam_misc\extra_crk\RUNE\steam_emu.ini'
_AddInterfaces($rune_ini)
FileDelete($interfaces_ini)
Func _AddInterfaces($crack_ini)
If FileExists($crack_ini) Then
_ReplaceStringInFile($interfaces_ini, 'SteamAppDisableUpdate', 'SteamAppDisableUpdate=SteamAppDisableUpdate', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMAPPLIST_', 'SteamAppList=STEAMAPPLIST_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMAPPS_', 'SteamApps=STEAMAPPS_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMAPPTICKET_', 'SteamAppTicket=STEAMAPPTICKET_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamClient', 'SteamClient=SteamClient', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamController', 'SteamController=SteamController', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamFriends', 'SteamFriends=SteamFriends', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamGameCoordinator', 'SteamGameCoordinator=SteamGameCoordinator', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamGameServerStats', 'Steam_Game_Server_Stats=Steam_Game_Server_Stats', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamGameServer', 'SteamGameServer=SteamGameServer', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'Steam_Game_Server_Stats', 'SteamGameServerStats', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamGameStats', 'SteamGameStats=SteamGameStats', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMHTMLSURFACE_', 'SteamHTMLSurface=STEAMHTMLSURFACE_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMHTTP_', 'SteamHTTP=STEAMHTTP_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamInput', 'SteamInput=SteamInput', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMINVENTORY_', 'SteamInventory=STEAMINVENTORY_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamMasterServerUpdater', 'SteamMasterServerUpdater=SteamMasterServerUpdater', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamMatchGameSearch', 'SteamMatchGameSearch=SteamMatchGameSearch', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamMatchMakingServers', 'Steam_Match_Making_Servers=Steam_Match_Making_Servers', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamMatchMaking', 'SteamMatchMaking=SteamMatchMaking', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'Steam_Match_Making_Servers', 'SteamMatchMakingServers', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMMUSIC_', 'SteamMusic=STEAMMUSIC_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMMUSICREMOTE_', 'SteamMusicRemote=STEAMMUSICREMOTE_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamNetworkingMessages', 'Steam_Networking_Messages=Steam_Networking_Messages', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamNetworkingSocketsSerialized', 'Steam_Networking_Sockets_Serialized=Steam_Networking_Sockets_Serialized', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamNetworkingSockets', 'Steam_Networking_Sockets=Steam_Networking_Sockets', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamNetworkingUtils', 'Steam_Networking_Utils=Steam_Networking_Utils', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamNetworking', 'SteamNetworking=SteamNetworking', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'Steam_Networking_Messages', 'SteamNetworkingMessages', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'Steam_Networking_Sockets_Serialized', 'SteamNetworkingSocketsSerialized', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'Steam_Networking_Sockets', 'SteamNetworkingSockets', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'Steam_Networking_Utils', 'SteamNetworkingUtils', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMPARENTALSETTINGS_', 'SteamParentalSettings=STEAMPARENTALSETTINGS_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamParties', 'SteamParties=SteamParties', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMREMOTEPLAY_', 'SteamRemotePlay=STEAMREMOTEPLAY_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMREMOTESTORAGE_', 'SteamRemoteStorage=STEAMREMOTESTORAGE_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMSCREENSHOTS_', 'SteamScreenshots=STEAMSCREENSHOTS_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMTIMELINE_', 'SteamTimeline=STEAMTIMELINE_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMTV_', 'SteamTV=STEAMTV_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMUGC_', 'SteamUGC=STEAMUGC_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMUNIFIEDMESSAGES_', 'SteamUnifiedMessages=STEAMUNIFIEDMESSAGES_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMUSERSTATS_', 'Steam_User_Stats=STEAMUSERSTATS_', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamUser', 'SteamUser=SteamUser', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'Steam_User_Stats', 'SteamUserStats', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'SteamUtils', 'SteamUtils=SteamUtils', 1, 1)
_ReplaceStringInFile($interfaces_ini, 'STEAMVIDEO_', 'SteamVideo=STEAMVIDEO_', 1, 1)
IniWrite($crack_ini, 'Interfaces', 'SteamAppDisableUpdate', IniRead($interfaces_ini, 'steam_interfaces', 'SteamAppDisableUpdate', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamAppList', IniRead($interfaces_ini, 'steam_interfaces', 'SteamAppList', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamApps', IniRead($interfaces_ini, 'steam_interfaces', 'SteamApps', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamAppTicket', IniRead($interfaces_ini, 'steam_interfaces', 'SteamAppTicket', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamClient', IniRead($interfaces_ini, 'steam_interfaces', 'SteamClient', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamController', IniRead($interfaces_ini, 'steam_interfaces', 'SteamController', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamFriends', IniRead($interfaces_ini, 'steam_interfaces', 'SteamFriends', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamGameCoordinator', IniRead($interfaces_ini, 'steam_interfaces', 'SteamGameCoordinator', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamGameServerStats', IniRead($interfaces_ini, 'steam_interfaces', 'SteamGameServerStats', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamGameServer', IniRead($interfaces_ini, 'steam_interfaces', 'SteamGameServer', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamGameStats', IniRead($interfaces_ini, 'steam_interfaces', 'SteamGameStats', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamHTMLSurface', IniRead($interfaces_ini, 'steam_interfaces', 'SteamHTMLSurface', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamHTTP', IniRead($interfaces_ini, 'steam_interfaces', 'SteamHTTP', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamInput', IniRead($interfaces_ini, 'steam_interfaces', 'SteamInput', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamInventory', IniRead($interfaces_ini, 'steam_interfaces', 'SteamInventory', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamMasterServerUpdater', IniRead($interfaces_ini, 'steam_interfaces', 'SteamMasterServerUpdater', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamMatchGameSearch', IniRead($interfaces_ini, 'steam_interfaces', 'SteamMatchGameSearch', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamMatchMakingServers', IniRead($interfaces_ini, 'steam_interfaces', 'SteamMatchMakingServers', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamMatchMaking', IniRead($interfaces_ini, 'steam_interfaces', 'SteamMatchMaking', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamMusic', IniRead($interfaces_ini, 'steam_interfaces', 'SteamMusic', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamMusicRemote', IniRead($interfaces_ini, 'steam_interfaces', 'SteamMusicRemote', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamNetworkingMessages', IniRead($interfaces_ini, 'steam_interfaces', 'SteamNetworkingMessages', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamNetworkingSocketsSerialized', IniRead($interfaces_ini, 'steam_interfaces', 'SteamNetworkingSocketsSerialized', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamNetworkingSockets', IniRead($interfaces_ini, 'steam_interfaces', 'SteamNetworkingSockets', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamNetworkingUtils', IniRead($interfaces_ini, 'steam_interfaces', 'SteamNetworkingUtils', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamNetworking', IniRead($interfaces_ini, 'steam_interfaces', 'SteamNetworking', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamParentalSettings', IniRead($interfaces_ini, 'steam_interfaces', 'SteamParentalSettings', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamParties', IniRead($interfaces_ini, 'steam_interfaces', 'SteamParties', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamRemotePlay', IniRead($interfaces_ini, 'steam_interfaces', 'SteamRemotePlay', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamRemoteStorage', IniRead($interfaces_ini, 'steam_interfaces', 'SteamRemoteStorage', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamScreenshots', IniRead($interfaces_ini, 'steam_interfaces', 'SteamScreenshots', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamTimeline', IniRead($interfaces_ini, 'steam_interfaces', 'SteamTimeline', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamTV', IniRead($interfaces_ini, 'steam_interfaces', 'SteamTV', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamUGC', IniRead($interfaces_ini, 'steam_interfaces', 'SteamUGC', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamUnifiedMessages', IniRead($interfaces_ini, 'steam_interfaces', 'SteamUnifiedMessages', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamUserStats', IniRead($interfaces_ini, 'steam_interfaces', 'SteamUserStats', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamUser', IniRead($interfaces_ini, 'steam_interfaces', 'SteamUser', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamUtils', IniRead($interfaces_ini, 'steam_interfaces', 'SteamUtils', ''))
IniWrite($crack_ini, 'Interfaces', 'SteamVideo', IniRead($interfaces_ini, 'steam_interfaces', 'SteamVideo', ''))
EndIf
EndFunc

0
tools/generate_emu_config/_DEFAULT/0/gse_acw_helper.cfg → tools/generate_emu_config/_DEFAULT/1/gse_acw_helper.cfg
View File

0
tools/generate_emu_config/_DEFAULT/0/gse_acw_helper.exe → tools/generate_emu_config/_DEFAULT/1/gse_acw_helper.exe
View File

0
tools/generate_emu_config/_DEFAULT/0/gse_debug_switch.cfg → tools/generate_emu_config/_DEFAULT/1/gse_debug_switch.cfg
View File

0
tools/generate_emu_config/_DEFAULT/0/gse_debug_switch.exe → tools/generate_emu_config/_DEFAULT/1/gse_debug_switch.exe
View File

0
tools/generate_emu_config/_DEFAULT/0/gse_generate_interfaces.cfg → tools/generate_emu_config/_DEFAULT/1/gse_generate_interfaces.cfg
View File

0
tools/generate_emu_config/_DEFAULT/0/gse_generate_interfaces.exe → tools/generate_emu_config/_DEFAULT/1/gse_generate_interfaces.exe
View File

0
tools/generate_emu_config/_DEFAULT/0/gse_lobby_connect.cfg → tools/generate_emu_config/_DEFAULT/1/gse_lobby_connect.cfg
View File

0
tools/generate_emu_config/_DEFAULT/0/gse_lobby_connect.exe → tools/generate_emu_config/_DEFAULT/1/gse_lobby_connect.exe
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/7za/7za-license.txt → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/7za/7za-license.txt
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/7za/7za.exe → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/7za/7za.exe
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/au3-license.txt → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/au3-license.txt
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/au3.exe → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/au3.exe
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/acw_helper.a3x → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/acw_helper.a3x
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/acw_helper.au3 → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/acw_helper.au3
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/acw_helper.ini → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/acw_helper.ini
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/debug_switch.a3x → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/debug_switch.a3x
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/debug_switch.au3 → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/debug_switch.au3
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/debug_switch.ini → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/debug_switch.ini
View File

0
tools/migrate_gse/_DEFAULT/0/steam_misc/tools/au3/scripts/generate_interfaces.a3x → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/generate_interfaces.a3x
View File

0
tools/migrate_gse/_DEFAULT/0/steam_misc/tools/au3/scripts/generate_interfaces.au3 → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/generate_interfaces.au3
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/generate_interfaces.ini → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/generate_interfaces.ini
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/lobby_connect.a3x → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/lobby_connect.a3x
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/lobby_connect.au3 → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/lobby_connect.au3
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/au3/scripts/lobby_connect.ini → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/au3/scripts/lobby_connect.ini
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/bat/acw_helper.bat → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/bat/acw_helper.bat
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/bat/debug_switch.bat → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/bat/debug_switch.bat
View File

0
tools/generate_emu_config/_DEFAULT/0/steam_misc/tools/bat/generate_interfaces.bat → tools/generate_emu_config/_DEFAULT/1/steam_misc/tools/bat/generate_interfaces.bat
View File

Some files were not shown because too many files have changed in this diff Show More