├── .gitattributes
├── .github
    ├── actions
    │   └── godot-install
    │   │   └── action.yml
    ├── version
    │   └── GitVersion.yml
    └── workflows
    │   └── build_test_deploy.yml
├── .gitignore
├── .runsettings
├── .runsettings-ci
├── Example
    ├── GlobalReferences.cs
    ├── GlobalReferences.cs.uid
    ├── Player.cs
    ├── Player.cs.uid
    ├── Player.tscn
    ├── Startup.tscn
    ├── UI.cs
    └── UI.cs.uid
├── Facepunch
    ├── Facepunch.Steamworks.Posix.dll
    └── Facepunch.Steamworks.Win64.dll
├── LICENSE.txt
├── Properties
    └── launchSettings.json
├── README.md
├── Steam
    ├── SteamConnection.cs
    ├── SteamConnection.cs.uid
    ├── SteamConnectionManager.cs
    ├── SteamConnectionManager.cs.uid
    ├── SteamExtensions.cs
    ├── SteamExtensions.cs.uid
    ├── SteamManager.cs
    ├── SteamManager.cs.uid
    ├── SteamMultiplayerPeer.cs
    ├── SteamMultiplayerPeer.cs.uid
    ├── SteamNetworkingMessage.cs
    ├── SteamNetworkingMessage.cs.uid
    ├── SteamPacketPeer.cs
    ├── SteamPacketPeer.cs.uid
    ├── SteamSocketManager.cs
    └── SteamSocketManager.cs.uid
├── SteamMultiplayerPeer.csproj
├── SteamMultiplayerPeer.sln
├── Tests
    ├── SteamManagerTests.cs
    ├── SteamManagerTests.cs.uid
    ├── Usings.cs
    └── Usings.cs.uid
├── icon.svg
├── icon.svg.import
├── project.godot
├── steam_api.dll
└── steam_api64.dll


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Normalize EOL for all files that Git considers text files.
2 | * text=auto eol=lf
3 | 


--------------------------------------------------------------------------------
/.github/actions/godot-install/action.yml:
--------------------------------------------------------------------------------
 1 | ## Taken from : https://github.com/MikeSchulze/gdUnit4Mono/blob/master/.github/actions/godot-install/action.yml
 2 | 
 3 | name: install-godot-binary
 4 | description: "Installs the Godot Runtime"
 5 | 
 6 | inputs:
 7 |   godot-version:
 8 |     description: "The Godot engine version"
 9 |     required: true
10 |   godot-status-version:
11 |     description: "The Godot engine status version"
12 |     required: true
13 |   godot-mono:
14 |     required: false
15 |     default: "false"
16 |   godot-bin-name:
17 |     required: true
18 |   godot-cache-path:
19 |     required: true
20 | 
21 | runs:
22 |   using: composite
23 |   steps:
24 |     - name: "Set Cache Name"
25 |       shell: bash
26 |       run: |
27 |         if ${{inputs.godot-mono == 'true'}}; then
28 |             echo "CACHE_NAME=${{ runner.OS }}-Godot_v${{ inputs.godot-version }}-${{ inputs.godot-status-version }}_mono" >> "$GITHUB_ENV"
29 |         else
30 |             echo "CACHE_NAME=${{ runner.OS }}-Godot_v${{ inputs.godot-version }}-${{ inputs.godot-status-version }}" >> "$GITHUB_ENV"
31 |         fi
32 | 
33 |     - name: "Build Cache"
34 |       uses: actions/cache@v4
35 |       id: godot-cache-binary
36 |       with:
37 |         path: ${{ inputs.godot-cache-path }}
38 |         key: ${{ env.CACHE_NAME }}
39 |         restore-keys: ${{ env.CACHE_NAME }}
40 | 
41 |     - name: "Download and Install Godot ${{ inputs.godot-version }}"
42 |       if: steps.godot-cache-binary.outputs.cache-hit != 'true'
43 |       continue-on-error: false
44 |       shell: bash
45 |       run: |
46 |         mkdir -p ${{ inputs.godot-cache-path }}
47 |         chmod 770 ${{ inputs.godot-cache-path }}
48 |         DIR="$HOME/.config/godot"
49 |         if [ ! -d "$DIR" ]; then
50 |           mkdir -p "$DIR"
51 |           chmod 770 "$DIR"
52 |         fi
53 | 
54 |         DOWNLOAD_URL=https://github.com/godotengine/godot-builds/releases/download/${{ inputs.godot-version }}-${{ inputs.godot-status-version }}
55 |         GODOT_BIN=Godot_v${{ inputs.godot-version }}-${{ inputs.godot-status-version }}_${{ inputs.godot-bin-name }}
56 |         if ${{inputs.godot-mono == 'true'}}; then
57 |           GODOT_BIN=Godot_v${{ inputs.godot-version }}-${{ inputs.godot-status-version }}_mono_${{ inputs.godot-bin-name }}
58 |         fi
59 | 
60 |         GODOT_PACKAGE=$GODOT_BIN.zip
61 |         wget $DOWNLOAD_URL/$GODOT_PACKAGE -P ${{ inputs.godot-cache-path }}
62 |         unzip ${{ inputs.godot-cache-path }}/$GODOT_PACKAGE -d ${{ inputs.godot-cache-path }}
63 |         rm -rf ${{ inputs.godot-cache-path }}/$GODOT_PACKAGE
64 | 
65 |         if ${{runner.OS == 'Linux'}}; then
66 |           echo "Run linux part"
67 | 
68 |           if ${{inputs.godot-mono == 'true'}}; then
69 |             mv ${{ inputs.godot-cache-path }}/$GODOT_BIN/* ${{ inputs.godot-cache-path }}
70 |             rmdir ${{ inputs.godot-cache-path }}/$GODOT_BIN/
71 |           fi
72 | 
73 |           mv ${{ inputs.godot-cache-path }}/Godot_v* ${{ inputs.godot-cache-path }}/godot
74 |           chmod u+x ${{ inputs.godot-cache-path }}/godot
75 |           echo "${{ inputs.godot-cache-path }}/godot"
76 |         else
77 |           echo "Run windows part"
78 |           pwd
79 |           mv ${{ inputs.godot-cache-path }}/$GODOT_BIN ${{ inputs.godot-cache-path }}/godot.exe
80 |           chmod u+x ${{ inputs.godot-cache-path }}/godot.exe
81 |           ${{ inputs.godot-cache-path }}/godot.exe --version
82 |           echo "${{ inputs.godot-cache-path }}/godot.exe"
83 |         fi


--------------------------------------------------------------------------------
/.github/version/GitVersion.yml:
--------------------------------------------------------------------------------
 1 | assembly-versioning-scheme: MajorMinorPatch
 2 | mode: Mainline
 3 | continuous-delivery-fallback-tag: ''
 4 | major-version-bump-message: '\+semver:\s?(breaking|major)'
 5 | minor-version-bump-message: '\+semver:\s?(feature|minor)'
 6 | patch-version-bump-message: '\+semver:\s?(fix|patch)'
 7 | branches: {}
 8 | ignore:
 9 |   sha: []
10 | commit-date-format: R
11 | merge-message-formats: {}


--------------------------------------------------------------------------------
/.github/workflows/build_test_deploy.yml:
--------------------------------------------------------------------------------
 1 | name: .NET Build and Godot Test
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ "master" ]
 6 | 
 7 | jobs:
 8 |   build-and-test:
 9 |     name: "Build and Test"
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       - uses: actions/checkout@v4
13 |         with:
14 |           lfs: true
15 |           fetch-depth: 0
16 | 
17 |       - name: Install GitVersion
18 |         uses: gittools/actions/gitversion/setup@v0.9.7
19 |         with:
20 |           versionSpec: '5.x'
21 | 
22 |       - name: Determine Version
23 |         id:   gitversion # id to later be referenced
24 |         uses: gittools/actions/gitversion/execute@v0 
25 |         with:
26 |           useConfigFile: true
27 |           configFilePath: .github/version/GitVersion.yml
28 | 
29 |       - name: "Install Godot Mono '4.2.1'"
30 |         uses: ./.github/actions/godot-install
31 |         with:
32 |           godot-version: '4.2.1'
33 |           godot-mono: true
34 |           godot-status-version: 'stable'
35 |           godot-bin-name: 'linux_x86_64'
36 |           godot-cache-path: '~/godot-linux'
37 | 
38 |       - uses: actions/setup-dotnet@v4
39 |         with:
40 |           dotnet-version: 8.0.x
41 | 
42 |       - name: "Build and Restore"
43 |         if: ${{ !cancelled() }}
44 |         run: |
45 |           dotnet restore SteamMultiplayerPeer.csproj
46 |           dotnet build --no-restore SteamMultiplayerPeer.csproj
47 | 
48 |           #this is 1000% going to fail. I need the container to have steam running on it with an authenticated account. Super duper fun stuff here, not sure how I am going to handle this. TODO 
49 |       - name: "Run Unit Tests"
50 |         if: ${{ !cancelled() }}
51 |         timeout-minutes: 5
52 |         env:
53 |           GODOT_BIN: "/home/runner/godot-linux/godot"
54 |         run: |
55 |           $GODOT_BIN --headless --build-solutions --quit-after 20
56 |           xvfb-run --auto-servernum dotnet test GodotVoipNet.csproj --no-build --settings .runsettings-ci
57 | 
58 | 
59 |       # eventually come back to.
60 | 
61 |       # - name: Package nuget
62 |       #   run: dotnet pack SteamMultiplayerPeer.csproj --configuration Release -o:package /p:PackageVersion=${{ steps.gitversion.outputs.AssemblySemVer }}
63 | 
64 |       # - name: Push Package to NuGet.org
65 |       #   run: dotnet nuget push ./package/*.nupkg -k ${{ secrets.NUGET_API_KEY }} -s https://api.nuget.org/v3/index.json --skip-duplicate
66 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | ##
  4 | ## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore
  5 | 
  6 | # User-specific files
  7 | *.rsuser
  8 | *.suo
  9 | *.user
 10 | *.userosscache
 11 | *.sln.docstates
 12 | 
 13 | # User-specific files (MonoDevelop/Xamarin Studio)
 14 | *.userprefs
 15 | 
 16 | # Mono auto generated files
 17 | mono_crash.*
 18 | 
 19 | # Build results
 20 | [Dd]ebug/
 21 | [Dd]ebugPublic/
 22 | [Rr]elease/
 23 | [Rr]eleases/
 24 | x64/
 25 | x86/
 26 | [Ww][Ii][Nn]32/
 27 | [Aa][Rr][Mm]/
 28 | [Aa][Rr][Mm]64/
 29 | bld/
 30 | [Bb]in/
 31 | [Oo]bj/
 32 | [Ll]og/
 33 | [Ll]ogs/
 34 | 
 35 | # Visual Studio 2015/2017 cache/options directory
 36 | .vs/
 37 | # Uncomment if you have tasks that create the project's static files in wwwroot
 38 | #wwwroot/
 39 | 
 40 | # Visual Studio 2017 auto generated files
 41 | Generated\ Files/
 42 | 
 43 | # MSTest test Results
 44 | [Tt]est[Rr]esult*/
 45 | [Bb]uild[Ll]og.*
 46 | 
 47 | # NUnit
 48 | *.VisualState.xml
 49 | TestResult.xml
 50 | nunit-*.xml
 51 | 
 52 | # Build Results of an ATL Project
 53 | [Dd]ebugPS/
 54 | [Rr]eleasePS/
 55 | dlldata.c
 56 | 
 57 | # Benchmark Results
 58 | BenchmarkDotNet.Artifacts/
 59 | 
 60 | # .NET Core
 61 | project.lock.json
 62 | project.fragment.lock.json
 63 | artifacts/
 64 | 
 65 | # ASP.NET Scaffolding
 66 | ScaffoldingReadMe.txt
 67 | 
 68 | # StyleCop
 69 | StyleCopReport.xml
 70 | 
 71 | # Files built by Visual Studio
 72 | *_i.c
 73 | *_p.c
 74 | *_h.h
 75 | *.ilk
 76 | *.meta
 77 | *.obj
 78 | *.iobj
 79 | *.pch
 80 | *.pdb
 81 | *.ipdb
 82 | *.pgc
 83 | *.pgd
 84 | *.rsp
 85 | *.sbr
 86 | *.tlb
 87 | *.tli
 88 | *.tlh
 89 | *.tmp
 90 | *.tmp_proj
 91 | *_wpftmp.csproj
 92 | *.log
 93 | *.tlog
 94 | *.vspscc
 95 | *.vssscc
 96 | .builds
 97 | *.pidb
 98 | *.svclog
 99 | *.scc
100 | 
101 | # Chutzpah Test files
102 | _Chutzpah*
103 | 
104 | # Visual C++ cache files
105 | ipch/
106 | *.aps
107 | *.ncb
108 | *.opendb
109 | *.opensdf
110 | *.sdf
111 | *.cachefile
112 | *.VC.db
113 | *.VC.VC.opendb
114 | 
115 | # Visual Studio profiler
116 | *.psess
117 | *.vsp
118 | *.vspx
119 | *.sap
120 | 
121 | # Visual Studio Trace Files
122 | *.e2e
123 | 
124 | # TFS 2012 Local Workspace
125 | $tf/
126 | 
127 | # Guidance Automation Toolkit
128 | *.gpState
129 | 
130 | # ReSharper is a .NET coding add-in
131 | _ReSharper*/
132 | *.[Rr]e[Ss]harper
133 | *.DotSettings.user
134 | 
135 | # TeamCity is a build add-in
136 | _TeamCity*
137 | 
138 | # DotCover is a Code Coverage Tool
139 | *.dotCover
140 | 
141 | # AxoCover is a Code Coverage Tool
142 | .axoCover/*
143 | !.axoCover/settings.json
144 | 
145 | # Coverlet is a free, cross platform Code Coverage Tool
146 | coverage*.json
147 | coverage*.xml
148 | coverage*.info
149 | 
150 | # Visual Studio code coverage results
151 | *.coverage
152 | *.coveragexml
153 | 
154 | # NCrunch
155 | _NCrunch_*
156 | .*crunch*.local.xml
157 | nCrunchTemp_*
158 | 
159 | # MightyMoose
160 | *.mm.*
161 | AutoTest.Net/
162 | 
163 | # Web workbench (sass)
164 | .sass-cache/
165 | 
166 | # Installshield output folder
167 | [Ee]xpress/
168 | 
169 | # DocProject is a documentation generator add-in
170 | DocProject/buildhelp/
171 | DocProject/Help/*.HxT
172 | DocProject/Help/*.HxC
173 | DocProject/Help/*.hhc
174 | DocProject/Help/*.hhk
175 | DocProject/Help/*.hhp
176 | DocProject/Help/Html2
177 | DocProject/Help/html
178 | 
179 | # Click-Once directory
180 | publish/
181 | 
182 | # Publish Web Output
183 | *.[Pp]ublish.xml
184 | *.azurePubxml
185 | # Note: Comment the next line if you want to checkin your web deploy settings,
186 | # but database connection strings (with potential passwords) will be unencrypted
187 | *.pubxml
188 | *.publishproj
189 | 
190 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
191 | # checkin your Azure Web App publish settings, but sensitive information contained
192 | # in these scripts will be unencrypted
193 | PublishScripts/
194 | 
195 | # NuGet Packages
196 | *.nupkg
197 | # NuGet Symbol Packages
198 | *.snupkg
199 | # The packages folder can be ignored because of Package Restore
200 | **/[Pp]ackages/*
201 | # except build/, which is used as an MSBuild target.
202 | !**/[Pp]ackages/build/
203 | # Uncomment if necessary however generally it will be regenerated when needed
204 | #!**/[Pp]ackages/repositories.config
205 | # NuGet v3's project.json files produces more ignorable files
206 | *.nuget.props
207 | *.nuget.targets
208 | 
209 | # Microsoft Azure Build Output
210 | csx/
211 | *.build.csdef
212 | 
213 | # Microsoft Azure Emulator
214 | ecf/
215 | rcf/
216 | 
217 | # Windows Store app package directories and files
218 | AppPackages/
219 | BundleArtifacts/
220 | Package.StoreAssociation.xml
221 | _pkginfo.txt
222 | *.appx
223 | *.appxbundle
224 | *.appxupload
225 | 
226 | # Visual Studio cache files
227 | # files ending in .cache can be ignored
228 | *.[Cc]ache
229 | # but keep track of directories ending in .cache
230 | !?*.[Cc]ache/
231 | 
232 | # Others
233 | ClientBin/
234 | ~$*
235 | *~
236 | *.dbmdl
237 | *.dbproj.schemaview
238 | *.jfm
239 | *.pfx
240 | *.publishsettings
241 | orleans.codegen.cs
242 | 
243 | # Including strong name files can present a security risk
244 | # (https://github.com/github/gitignore/pull/2483#issue-259490424)
245 | #*.snk
246 | 
247 | # Since there are multiple workflows, uncomment next line to ignore bower_components
248 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
249 | #bower_components/
250 | 
251 | # RIA/Silverlight projects
252 | Generated_Code/
253 | 
254 | # Backup & report files from converting an old project file
255 | # to a newer Visual Studio version. Backup files are not needed,
256 | # because we have git ;-)
257 | _UpgradeReport_Files/
258 | Backup*/
259 | UpgradeLog*.XML
260 | UpgradeLog*.htm
261 | ServiceFabricBackup/
262 | *.rptproj.bak
263 | 
264 | # SQL Server files
265 | *.mdf
266 | *.ldf
267 | *.ndf
268 | 
269 | # Business Intelligence projects
270 | *.rdl.data
271 | *.bim.layout
272 | *.bim_*.settings
273 | *.rptproj.rsuser
274 | *- [Bb]ackup.rdl
275 | *- [Bb]ackup ([0-9]).rdl
276 | *- [Bb]ackup ([0-9][0-9]).rdl
277 | 
278 | # Microsoft Fakes
279 | FakesAssemblies/
280 | 
281 | # GhostDoc plugin setting file
282 | *.GhostDoc.xml
283 | 
284 | # Node.js Tools for Visual Studio
285 | .ntvs_analysis.dat
286 | node_modules/
287 | 
288 | # Visual Studio 6 build log
289 | *.plg
290 | 
291 | # Visual Studio 6 workspace options file
292 | *.opt
293 | 
294 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
295 | *.vbw
296 | 
297 | # Visual Studio 6 auto-generated project file (contains which files were open etc.)
298 | *.vbp
299 | 
300 | # Visual Studio 6 workspace and project file (working project files containing files to include in project)
301 | *.dsw
302 | *.dsp
303 | 
304 | # Visual Studio 6 technical files
305 | *.ncb
306 | *.aps
307 | 
308 | # Visual Studio LightSwitch build output
309 | **/*.HTMLClient/GeneratedArtifacts
310 | **/*.DesktopClient/GeneratedArtifacts
311 | **/*.DesktopClient/ModelManifest.xml
312 | **/*.Server/GeneratedArtifacts
313 | **/*.Server/ModelManifest.xml
314 | _Pvt_Extensions
315 | 
316 | # Paket dependency manager
317 | .paket/paket.exe
318 | paket-files/
319 | 
320 | # FAKE - F# Make
321 | .fake/
322 | 
323 | # CodeRush personal settings
324 | .cr/personal
325 | 
326 | # Python Tools for Visual Studio (PTVS)
327 | __pycache__/
328 | *.pyc
329 | 
330 | # Cake - Uncomment if you are using it
331 | # tools/**
332 | # !tools/packages.config
333 | 
334 | # Tabs Studio
335 | *.tss
336 | 
337 | # Telerik's JustMock configuration file
338 | *.jmconfig
339 | 
340 | # BizTalk build output
341 | *.btp.cs
342 | *.btm.cs
343 | *.odx.cs
344 | *.xsd.cs
345 | 
346 | # OpenCover UI analysis results
347 | OpenCover/
348 | 
349 | # Azure Stream Analytics local run output
350 | ASALocalRun/
351 | 
352 | # MSBuild Binary and Structured Log
353 | *.binlog
354 | 
355 | # NVidia Nsight GPU debugger configuration file
356 | *.nvuser
357 | 
358 | # MFractors (Xamarin productivity tool) working folder
359 | .mfractor/
360 | 
361 | # Local History for Visual Studio
362 | .localhistory/
363 | 
364 | # Visual Studio History (VSHistory) files
365 | .vshistory/
366 | 
367 | # BeatPulse healthcheck temp database
368 | healthchecksdb
369 | 
370 | # Backup folder for Package Reference Convert tool in Visual Studio 2017
371 | MigrationBackup/
372 | 
373 | # Ionide (cross platform F# VS Code tools) working folder
374 | .ionide/
375 | 
376 | # Fody - auto-generated XML schema
377 | FodyWeavers.xsd
378 | 
379 | # VS Code files for those working on multiple tools
380 | .vscode/*
381 | !.vscode/settings.json
382 | !.vscode/tasks.json
383 | !.vscode/launch.json
384 | !.vscode/extensions.json
385 | *.code-workspace
386 | 
387 | # Local History for Visual Studio Code
388 | .history/
389 | 
390 | # Windows Installer files from build outputs
391 | *.cab
392 | *.msi
393 | *.msix
394 | *.msm
395 | *.msp
396 | 
397 | # JetBrains Rider
398 | *.sln.iml
399 | /.godot
400 | /settings.json
401 | 
402 | # Gd Unit 4
403 | .godot
404 | 
405 | gdunit4_testadapter/
406 | 
407 | *.old


--------------------------------------------------------------------------------
/.runsettings:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RunSettings>
 3 |     <RunConfiguration>
 4 |         <MaxCpuCount>1</MaxCpuCount>
 5 |         <ResultsDirectory>./TestResults</ResultsDirectory>
 6 |         <TargetFrameworkVersion>net8.0</TargetFrameworkVersion>
 7 |         <TestSessionTimeout>180000</TestSessionTimeout>
 8 |         <TreatNoTestsAsError>true</TreatNoTestsAsError>
 9 |         <EnvironmentVariables>
10 |             <GODOT_BIN>C:\Program Files (x86)\Godot\Godot_v4.2.1-stable_mono_win64\Godot_v4.2.1-stable_mono_win64.exe</GODOT_BIN>
11 |         </EnvironmentVariables>
12 |     </RunConfiguration>
13 | 
14 |     <LoggerRunSettings>
15 |         <Loggers>
16 |             <Logger friendlyName="console" enabled="True">
17 |                 <Configuration>
18 |                     <Verbosity>detailed</Verbosity>
19 |                 </Configuration>
20 |             </Logger>
21 |             <Logger friendlyName="html" enabled="True">
22 |                 <Configuration>
23 |                     <LogFileName>test-result.html</LogFileName>
24 |                 </Configuration>
25 |             </Logger>
26 |             <Logger friendlyName="trx" enabled="True">
27 |                 <Configuration>
28 |                     <LogFileName>test-result.trx</LogFileName>
29 |                 </Configuration>
30 |             </Logger>
31 |         </Loggers>
32 |     </LoggerRunSettings>
33 | 
34 |     <GdUnit4>
35 |         <Parameters></Parameters>
36 |         <DisplayName>FullyQualifiedName</DisplayName>
37 |     </GdUnit4>
38 | </RunSettings>


--------------------------------------------------------------------------------
/.runsettings-ci:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RunSettings>
 3 |     <RunConfiguration>
 4 |         <MaxCpuCount>1</MaxCpuCount>
 5 |         <ResultsDirectory>./TestResults</ResultsDirectory>
 6 |         <TargetFrameworkVersion>net8.0</TargetFrameworkVersion>
 7 |         <TestSessionTimeout>180000</TestSessionTimeout>
 8 |         <TreatNoTestsAsError>true</TreatNoTestsAsError>
 9 |     </RunConfiguration>
10 | 
11 |     <LoggerRunSettings>
12 |         <Loggers>
13 |             <Logger friendlyName="console" enabled="True">
14 |                 <Configuration>
15 |                     <Verbosity>detailed</Verbosity>
16 |                 </Configuration>
17 |             </Logger>
18 |             <Logger friendlyName="html" enabled="True">
19 |                 <Configuration>
20 |                     <LogFileName>test-result.html</LogFileName>
21 |                 </Configuration>
22 |             </Logger>
23 |             <Logger friendlyName="trx" enabled="True">
24 |                 <Configuration>
25 |                     <LogFileName>test-result.trx</LogFileName>
26 |                 </Configuration>
27 |             </Logger>
28 |         </Loggers>
29 |     </LoggerRunSettings>
30 | 
31 |     <DataCollectionRunSettings>
32 |         <DataCollectors>
33 |             <DataCollector friendlyName="blame" enabled="True">
34 |                 <Configuration>
35 |                     <CollectDump DumpType="Full" />
36 |                     <CollectDumpOnTestSessionHang TestTimeout="10min" HangDumpType="Full" />
37 |                 </Configuration>
38 |             </DataCollector>
39 |         </DataCollectors>
40 |     </DataCollectionRunSettings>
41 | 
42 |     <GdUnit4>
43 |         <Parameters>--audio-driver Dummy --display-driver x11 --rendering-driver opengl3 --screen 0 --verbose</Parameters>
44 |         <DisplayName>FullyQualifiedName</DisplayName>
45 |     </GdUnit4>
46 | </RunSettings>


--------------------------------------------------------------------------------
/Example/GlobalReferences.cs:
--------------------------------------------------------------------------------
 1 | using Godot;
 2 | using Steam;
 3 | 
 4 | namespace SteamMultiplayerPeer.Example;
 5 | internal static class GlobalReferences // is this bad practice? idk its an example project
 6 | {
 7 |     public static SteamManager SteamManager(this Node node) => node.GetTree().Root.GetNode<SteamManager>("Startup/SteamManager");
 8 | 
 9 | }
10 | 


--------------------------------------------------------------------------------
/Example/GlobalReferences.cs.uid:
--------------------------------------------------------------------------------
1 | uid://c0khhu8ofy4ct
2 | 


--------------------------------------------------------------------------------
/Example/Player.cs:
--------------------------------------------------------------------------------
 1 | using Godot;
 2 | using System;
 3 | 
 4 | internal partial class Player : Node3D
 5 | {
 6 | 
 7 |     public override void _EnterTree()
 8 |     {
 9 |         SetMultiplayerAuthority((int)long.Parse(Name));
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/Example/Player.cs.uid:
--------------------------------------------------------------------------------
1 | uid://o64rv5mh52y2
2 | 


--------------------------------------------------------------------------------
/Example/Player.tscn:
--------------------------------------------------------------------------------
1 | [gd_scene load_steps=2 format=3 uid="uid://d2isx4pc6x0ww"]
2 | 
3 | [ext_resource type="Script" uid="uid://o64rv5mh52y2" path="res://Example/Player.cs" id="1_h8r3t"]
4 | 
5 | [node name="Player" type="Node3D"]
6 | script = ExtResource("1_h8r3t")
7 | 


--------------------------------------------------------------------------------
/Example/Startup.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene load_steps=3 format=3 uid="uid://b27h0j08ndoxw"]
 2 | 
 3 | [ext_resource type="Script" uid="uid://b0smp6qoaxdgl" path="res://Steam/SteamManager.cs" id="1_ngv6v"]
 4 | [ext_resource type="Script" uid="uid://db1gw7slpkqjn" path="res://Example/UI.cs" id="2_tenw6"]
 5 | 
 6 | [node name="Startup" type="Node3D"]
 7 | 
 8 | [node name="SteamManager" type="Node" parent="."]
 9 | script = ExtResource("1_ngv6v")
10 | 
11 | [node name="UI" type="Control" parent="."]
12 | layout_mode = 3
13 | anchors_preset = 15
14 | anchor_right = 1.0
15 | anchor_bottom = 1.0
16 | grow_horizontal = 2
17 | grow_vertical = 2
18 | script = ExtResource("2_tenw6")
19 | 
20 | [node name="VBoxContainer" type="VBoxContainer" parent="UI"]
21 | layout_mode = 1
22 | anchors_preset = 5
23 | anchor_left = 0.5
24 | anchor_right = 0.5
25 | offset_left = -20.0
26 | offset_right = 20.0
27 | offset_bottom = 40.0
28 | grow_horizontal = 2
29 | 
30 | [node name="HostGame" type="Button" parent="UI/VBoxContainer"]
31 | layout_mode = 2
32 | text = "Host"
33 | 
34 | [node name="TextEdit" type="TextEdit" parent="UI/VBoxContainer"]
35 | custom_minimum_size = Vector2(150, 40)
36 | layout_mode = 2
37 | placeholder_text = "Lobby Id"
38 | 
39 | [node name="LeaveGame" type="Button" parent="UI/VBoxContainer"]
40 | layout_mode = 2
41 | text = "Leave"
42 | 
43 | [node name="JoinGame" type="Button" parent="UI/VBoxContainer"]
44 | layout_mode = 2
45 | text = "Join"
46 | 
47 | [node name="QuitGame" type="Button" parent="UI/VBoxContainer"]
48 | layout_mode = 2
49 | text = "Quit
50 | "
51 | 
52 | [node name="LobbyVbox" type="VBoxContainer" parent="UI"]
53 | layout_mode = 0
54 | offset_right = 40.0
55 | offset_bottom = 40.0
56 | 
57 | [node name="Label" type="Label" parent="UI/LobbyVbox"]
58 | layout_mode = 2
59 | text = "Lobby Information:"
60 | 
61 | [node name="HBoxContainer" type="HBoxContainer" parent="UI/LobbyVbox"]
62 | layout_mode = 2
63 | 
64 | [node name="Label" type="Label" parent="UI/LobbyVbox/HBoxContainer"]
65 | layout_mode = 2
66 | text = "Lobby Id: "
67 | 
68 | [node name="LobbyIdLabel" type="TextEdit" parent="UI/LobbyVbox/HBoxContainer"]
69 | custom_minimum_size = Vector2(200, 50)
70 | layout_mode = 2
71 | 
72 | [node name="CurrentMemberLabel" type="Label" parent="UI/LobbyVbox"]
73 | layout_mode = 2
74 | text = "CurrentMembers:"
75 | 
76 | [node name="MemberVbox" type="VBoxContainer" parent="UI/LobbyVbox"]
77 | layout_mode = 2
78 | 
79 | [node name="PlayerHolder" type="Node3D" parent="."]
80 | 
81 | [node name="MultiplayerSpawner" type="MultiplayerSpawner" parent="."]
82 | _spawnable_scenes = PackedStringArray("uid://d2isx4pc6x0ww")
83 | spawn_path = NodePath("../PlayerHolder")
84 | 


--------------------------------------------------------------------------------
/Example/UI.cs:
--------------------------------------------------------------------------------
  1 | using Godot;
  2 | using Godot.Collections;
  3 | using SteamMultiplayerPeer.Example;
  4 | using Steamworks.Data;
  5 | using System.Collections.Generic;
  6 | using System.Linq;
  7 | using System.Threading.Tasks;
  8 | internal partial class UI : Control
  9 | {
 10 |     private Button _hostButton = null!;
 11 |     private Button _joinButton = null!;
 12 |     private Button _leaveGameButton = null!;
 13 |     private Button _quitButton = null!;
 14 |     private TextEdit _lobbyIdLabel = null!;
 15 |     private TextEdit _textEdit = null!;
 16 |     private VBoxContainer _memberVbox = null!;
 17 |     private Node3D _playerSpawnerNode = null!;
 18 |     private PackedScene _playerScene = ResourceLoader.Load<PackedScene>("res://Example/Player.tscn");
 19 |     private bool _inLobby = false;
 20 |     public override void _Ready()
 21 |     {
 22 |         _hostButton = GetNode<Button>("VBoxContainer/HostGame");
 23 |         _joinButton = GetNode<Button>("VBoxContainer/JoinGame");
 24 |         _leaveGameButton = GetNode<Button>("VBoxContainer/LeaveGame");
 25 |         _quitButton = GetNode<Button>("VBoxContainer/QuitGame");
 26 |         _lobbyIdLabel = GetNode<TextEdit>("LobbyVbox/HBoxContainer/LobbyIdLabel");
 27 |         _textEdit = GetNode<TextEdit>("VBoxContainer/TextEdit");
 28 |         _memberVbox = GetNode<VBoxContainer>("LobbyVbox/MemberVbox");
 29 |         _playerSpawnerNode = GetParent().GetNode<Node3D>("PlayerHolder");
 30 | 
 31 |         _lobbyIdLabel.Editable = false;
 32 | 
 33 |         _hostButton.Pressed += async () => await OnHostButtonPressed();
 34 |         _joinButton.Pressed += async () => await OnJoinButtonPressed();
 35 | 
 36 |         _leaveGameButton.Pressed += () =>
 37 |         {
 38 |             _inLobby = false;
 39 |             Multiplayer.MultiplayerPeer?.Close();
 40 |             Multiplayer.MultiplayerPeer = null;
 41 |             this.SteamManager().LeaveLobby();
 42 |         };
 43 | 
 44 |         _quitButton.Pressed += OnQuitButtonPressed;
 45 | 
 46 |         this.SteamManager().OnLobbyRefreshCompleted += (List<Lobby> lobbies) => // you would pretty obviously not want to do this exact implementation in a real game, but for the sake of the example
 47 |         {
 48 |             Lobby? lobby = lobbies.FirstOrDefault(x => x.Id.Value == ulong.Parse(_textEdit.Text));
 49 | 
 50 |             if (lobby is not null)
 51 |             {
 52 |                 lobby.Value.Join();
 53 | 
 54 |                 Timer timer = new Timer(); // shit implementation but you need to load the owner id here and it takes a sec, make the joining lobby awaitable
 55 |                 AddChild(timer);
 56 |                 timer.OneShot = true;
 57 |                 timer.WaitTime = 1.0d;
 58 |                 timer.Timeout += () =>
 59 |                 {
 60 |                     _inLobby = true;
 61 |                     Steam.SteamMultiplayerPeer peer = new Steam.SteamMultiplayerPeer();
 62 |                     peer.CreateClient(this.SteamManager().PlayerSteamID, lobby.Value.Owner.Id);
 63 |                     Multiplayer.MultiplayerPeer = peer;
 64 |                 };
 65 |                 timer.Start();
 66 |             }
 67 |         };
 68 |     }
 69 | 
 70 |     public override void _Process(double delta)
 71 |     {
 72 |         _hostButton.Disabled = _inLobby;
 73 |         _joinButton.Disabled = string.IsNullOrEmpty(_textEdit.Text) || _inLobby;
 74 |         _leaveGameButton.Disabled = !_inLobby;
 75 |     }
 76 | 
 77 | 
 78 |     private async Task OnHostButtonPressed()
 79 |     {
 80 |         this.SteamManager().OnLobbySuccessfullyCreated += (lobbyId) =>
 81 |         {
 82 |             _lobbyIdLabel.Text = lobbyId.Id.ToString();
 83 |             Steam.SteamMultiplayerPeer steamMultiplayerPeer = new Steam.SteamMultiplayerPeer();
 84 |             steamMultiplayerPeer.CreateHost(25565);
 85 |             Multiplayer.MultiplayerPeer = steamMultiplayerPeer;
 86 | 
 87 |             AddPlayer(1);
 88 |             RefreshPlayerList(new Array<Variant>(new Variant[] { (Variant)"1"}));
 89 |         };
 90 | 
 91 |         Multiplayer.PeerConnected += (peer) =>
 92 |         {
 93 |             AddPlayer(peer);
 94 |             Rpc(nameof(RefreshPlayerList), new Array(_playerSpawnerNode.GetChildren().Cast<Player>().Select(x => (Variant)x.Name)));
 95 |         };
 96 |         Multiplayer.PeerDisconnected += (peer) =>
 97 |         {
 98 |             RemovePlayer(peer);
 99 |             Rpc(nameof(RefreshPlayerList), new Array(_playerSpawnerNode.GetChildren().Where(x => x.Name != peer.ToString()/*need to filter it here due to queuefree timing*/).Cast<Player>().Select(x => (Variant)x.Name)));
100 |         };
101 | 
102 |         _inLobby = true;
103 |         await this.SteamManager().CreateLobby();
104 | 
105 |     }
106 |     [Rpc(CallLocal = true)]
107 |     public void RefreshPlayerList(Array<Variant> players)
108 |     {
109 |         _memberVbox.GetChildren().ToList().ForEach(x => x.QueueFree());
110 |         foreach (var player in players)
111 |         {
112 |             _memberVbox.AddChild(new Label() { Text = player.ToString(), Name = player.ToString() });
113 |         }
114 |     }
115 | 
116 |     private async Task OnJoinButtonPressed()
117 |     {
118 |         await this.SteamManager().GetMultiplayerLobbies();
119 |     }
120 | 
121 |     private void OnQuitButtonPressed()
122 |     {
123 |         GetTree().Quit();
124 |     }
125 | 
126 |     private void AddPlayer(long id)
127 |     {
128 |         Player playerRef = _playerScene.Instantiate<Player>();
129 |         playerRef.Name = id.ToString();
130 |         _playerSpawnerNode.AddChild(playerRef, true);
131 |     }
132 |     private void RemovePlayer(long id)
133 |     {
134 |         Node? childNode = _playerSpawnerNode.GetChildren().FirstOrDefault(x => x.Name == id.ToString());
135 |         childNode?.QueueFree();
136 |     }
137 | }
138 | 


--------------------------------------------------------------------------------
/Example/UI.cs.uid:
--------------------------------------------------------------------------------
1 | uid://db1gw7slpkqjn
2 | 


--------------------------------------------------------------------------------
/Facepunch/Facepunch.Steamworks.Posix.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Pieeer1/SteamMultiplayerPeer/59b47989a40f8c728add74c9a0fb8fbbd07fafce/Facepunch/Facepunch.Steamworks.Posix.dll


--------------------------------------------------------------------------------
/Facepunch/Facepunch.Steamworks.Win64.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Pieeer1/SteamMultiplayerPeer/59b47989a40f8c728add74c9a0fb8fbbd07fafce/Facepunch/Facepunch.Steamworks.Win64.dll


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) [2024] [Mason Adams]
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Properties/launchSettings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "profiles": {
 3 |     "Trouble": {
 4 |       "commandName": "Project"
 5 |     },
 6 |     "Trouble Console": {
 7 |       "commandName": "Executable",
 8 |       "executablePath": "C:\\Program Files (x86)\\Godot\\Godot_v4.2.1-stable_mono_win64\\Godot_v4.2.1-stable_mono_win64_console.exe",
 9 |       "commandLineArgs": "--path. --verbose",
10 |       "workingDirectory": ".",
11 |       "nativeDebugging": true
12 |     },
13 |     "Trouble Debug": {
14 |       "commandName": "Executable",
15 |       "executablePath": "C:\\Program Files (x86)\\Godot\\Godot_v4.2.1-stable_mono_win64\\Godot_v4.2.1-stable_mono_win64.exe",
16 |       "commandLineArgs": "--path. --verbose",
17 |       "workingDirectory": ".",
18 |       "nativeDebugging": true
19 |     }
20 |   }
21 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Steam Multiplayer Peer
 2 | 
 3 | ## Description
 4 | 
 5 | The goal of this project is to greatly simplify the way that Steam Multiplayer is implemented in Godot. This project is a Godot Package that provides a simple API for creating and joining lobbies, and sending and receiving messages between players.
 6 | 
 7 | ## Installation
 8 | 
 9 | The example project shown above should give a good example on how to start up. A couple key things to note
10 | 
11 | Nuget Packaging is not working fully. Some nuance with the multi-platform builds. I will get to it sometime.
12 | 
13 | dotnet
14 | `dotnet add package SteamMultiplayerPeer`
15 | 
16 | package manager
17 | `Install-Package SteamMultiplayerPeer`
18 | 
19 | In the meantime, you can copy the code in the Steam Folder to your project, as well as the dll's, and follow the instructions below.
20 | 
21 | Once the package is installed you will have to add the following to the csproj:
22 | ```xml
23 |   <ItemGroup>
24 |     <Reference Include="Facepunch.Steamworks.Win64" Condition="'$(Configuration)' == 'Debug' and $([MSBuild]::IsOSPlatform('Windows'))">
25 |       <HintPath>.godot\mono\temp\bin\Debug\Facepunch.Steamworks.Win64.dll</HintPath>
26 |     </Reference>
27 |     <Reference Include="Facepunch.Steamworks.Win64" Condition="'$(Configuration)' == 'Release' and $([MSBuild]::IsOSPlatform('Windows'))">
28 |         <HintPath>.godot\mono\temp\bin\Release\Facepunch.Steamworks.Win64.dll</HintPath>
29 |     </Reference>
30 |     <Reference Include="Facepunch.Steamworks.Win64" Condition="'$(Configuration)' == 'Debug' and ($([MSBuild]::IsOSPlatform('Linux')) or $([MSBuild]::IsOSPlatform('OSX')))">
31 |         <HintPath>.godot\mono\temp\bin\Debug\Facepunch.Steamworks.Win64.dll</HintPath>
32 |     </Reference>
33 |     <Reference Include="Facepunch.Steamworks.Win64" Condition="'$(Configuration)' == 'Release' and ($([MSBuild]::IsOSPlatform('Linux')) or $([MSBuild]::IsOSPlatform('OSX')))">
34 |         <HintPath>.godot\mono\temp\bin\Release\Facepunch.Steamworks.Win64.dll</HintPath>
35 |     </Reference>
36 |   </ItemGroup>
37 | ```
38 | 
39 | The above snippet will add the Facepunch.Steamworks.Win64.dll to the project. This is the library that is used to connect to the Steam API.
40 | 
41 | 1. You will need to have a Steam account to use the Steamworks API. You can create a Steam account [here](https://store.steampowered.com/join/)
42 | 1. I highly recommend getting your own steam app ID and setting up your own app in the Steamworks dashboard. This will allow you to test your game without interfering with other people's games. You can find the Steamworks dashboard [here](https://partner.steamgames.com/home).
43 | 1. You will need to have the Steam client running on your computer to test the multiplayer. This is because the Steam API is used to connect to the Steam servers and create lobbies. You can download the Steam client [here](https://store.steampowered.com/about/).
44 | 
45 | 
46 | ## Usage
47 | 
48 | 1. Create a SteamManager Reference at the root of your tree. Call Ready:
49 | 
50 | ```csharp
51 | public SteamManager SteamManager { get; set; } = new SteamManager();
52 | 
53 | public override void _Ready()
54 | {
55 | 	SteamManager._Ready();
56 | }
57 | 
58 | ```
59 | 1. Set the SteamAppId to your AppId from the Steamworks dashboard.
60 | 1. This will start steam, and allow you to use the steam API (shift tab)
61 | 
62 | 
63 | ### Multiplayer
64 | 
65 | 1. Create a SteamMultiplayerPeer instance
66 | 1. Either create or host a lobby to run the game. 
67 |  
68 | ## FAQ
69 | 
70 | "It is not working locally"
71 | - Make sure that you have the Steam client running on your computer. This is required to connect to the Steam servers and create lobbies.
72 | - You will NEED TO HAVE A SECOND STEAM ACCOUNT RUNNING ON EITHER A SEPARATE COMPUTER OR A SEPARATE INSTANCE OF THE STEAM CLIENT WITH A SEPARATE INSTANCE. This is because the Steam API does not allow you to connect to the same lobby with the same account. This is a limitation of the Steam API, and there is no way around it.
73 | 
74 | ## License
75 | 
76 | This Project is Licensed under MIT License. See the [LICENSE](LICENSE.txt) file for more information.


--------------------------------------------------------------------------------
/Steam/SteamConnection.cs:
--------------------------------------------------------------------------------
 1 | using Godot;
 2 | using Steamworks;
 3 | using Steamworks.Data;
 4 | 
 5 | namespace Steam;
 6 | public partial class SteamConnection : RefCounted
 7 | {
 8 |     public SteamId SteamIdRaw { get; set; }
 9 |     public ulong SteamId => SteamIdRaw.Value;
10 |     public Connection Connection { get; set; }
11 |     public int PeerId { get; set; } = -1;
12 | 
13 |     public struct SetupPeerPayload
14 |     {
15 |         public int PeerId = -1;
16 | 
17 |         public SetupPeerPayload()
18 |         {
19 |         }
20 |     }
21 | 
22 |     public Error Send(SteamPacketPeer packet)
23 |     {
24 |         Error errorCode = RawSend(packet);
25 |         if (errorCode != Error.Ok)
26 |         {
27 |             return errorCode;
28 |         }
29 |         return Error.Ok;
30 |     }
31 | 
32 |     private Error RawSend(SteamPacketPeer packet)
33 |     {
34 |         return GetErrorFromResult(Connection.SendMessage(packet.Data, SendType.Reliable));
35 |     }
36 | 
37 |     private Error GetErrorFromResult(Result result) => result switch
38 |     {
39 |         //TODO - IMPLEMENT OTHER ERROR MESSAGES
40 |         Result.OK => Error.Ok,
41 |         Result.Fail => Error.Failed,
42 |         Result.NoConnection => Error.ConnectionError,
43 |         Result.InvalidParam => Error.InvalidParameter,
44 |         _ => Error.Bug
45 |     };
46 | 
47 |     public Error SendPeer(int uniqueId)
48 |     {
49 |         SetupPeerPayload payload = new SetupPeerPayload();
50 |         payload.PeerId = uniqueId;
51 |         return SendSetupPeer(payload);
52 |     }
53 | 
54 |     private Error SendSetupPeer(SetupPeerPayload payload)
55 |     {
56 |         return Send(new SteamPacketPeer(payload.ToBytes(), MultiplayerPeer.TransferModeEnum.Reliable));
57 |     }
58 | }


--------------------------------------------------------------------------------
/Steam/SteamConnection.cs.uid:
--------------------------------------------------------------------------------
1 | uid://iwbldbd3l7op
2 | 


--------------------------------------------------------------------------------
/Steam/SteamConnectionManager.cs:
--------------------------------------------------------------------------------
 1 | using Godot;
 2 | using Steamworks.Data;
 3 | using Steamworks;
 4 | using System;
 5 | using System.Collections.Generic;
 6 | using System.Runtime.InteropServices;
 7 | using System.Linq;
 8 | 
 9 | namespace Steam;
10 | public class SteamConnectionManager : ConnectionManager
11 | {
12 |     public event Action<ConnectionInfo>? OnConnectionEstablished;
13 |     public event Action<ConnectionInfo>? OnConnectionLost;
14 | 
15 |     private Queue<SteamNetworkingMessage> _pendingMessages { get; } = new Queue<SteamNetworkingMessage>();
16 |     public override void OnConnectionChanged(ConnectionInfo info)
17 |     {
18 |         base.OnConnectionChanged(info);
19 |     }
20 |     public override void OnConnected(ConnectionInfo info)
21 |     {
22 |         base.OnConnected(info);
23 |         OnConnectionEstablished?.Invoke(info);
24 |     }
25 | 
26 |     public override void OnConnecting(ConnectionInfo info)
27 |     {
28 |         base.OnConnecting(info);
29 |     }
30 | 
31 |     public override void OnDisconnected(ConnectionInfo info)
32 |     {
33 |         base.OnDisconnected(info);
34 |         OnConnectionLost?.Invoke(info);
35 |     }
36 | 
37 |     public override void OnMessage(IntPtr data, int size, long recvTime, long messageNum, int channel)
38 |     {
39 |         base.OnMessage(data, size, messageNum, recvTime, channel);
40 | 
41 |         byte[] managedArray = new byte[size];
42 |         Marshal.Copy(data, managedArray, 0, size);
43 | 
44 |         _pendingMessages.Enqueue(new SteamNetworkingMessage(managedArray, ConnectionInfo.Identity.SteamId, MultiplayerPeer.TransferModeEnum.Reliable, recvTime));
45 |     }
46 |     public IEnumerable<SteamNetworkingMessage> GetPendingMessages()
47 |     {
48 |         int maxMessageCount = _pendingMessages.Count;
49 |         for (int i = 0; i < maxMessageCount; i++)
50 |         {
51 |             yield return _pendingMessages.Dequeue();
52 |         }
53 |     }
54 | }


--------------------------------------------------------------------------------
/Steam/SteamConnectionManager.cs.uid:
--------------------------------------------------------------------------------
1 | uid://ciuqvminbffls
2 | 


--------------------------------------------------------------------------------
/Steam/SteamExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Runtime.InteropServices;
 3 | 
 4 | namespace Steam;
 5 | internal static class SteamExtensions
 6 | {
 7 |     public static byte[] ToBytes<T>(this T t) where T : struct
 8 |     {
 9 |         int size = Marshal.SizeOf(t);
10 |         byte[] arr = new byte[size];
11 | 
12 |         IntPtr ptr = IntPtr.Zero;
13 |         try
14 |         {
15 |             ptr = Marshal.AllocHGlobal(size);
16 |             Marshal.StructureToPtr(t, ptr, true);
17 |             Marshal.Copy(ptr, arr, 0, size);
18 |         }
19 |         finally
20 |         {
21 |             Marshal.FreeHGlobal(ptr);
22 |         }
23 |         return arr;
24 | 
25 |     }
26 |     public static T? ToStruct<T>(this byte[] bytes)
27 |     {
28 |         int size = Marshal.SizeOf(typeof(T));
29 |         if (bytes.Length < size)
30 |             throw new Exception("Invalid parameter");
31 | 
32 |         IntPtr ptr = Marshal.AllocHGlobal(size);
33 |         try
34 |         {
35 |             Marshal.Copy(bytes, 0, ptr, size);
36 |             return Marshal.PtrToStructure<T>(ptr);
37 |         }
38 |         finally
39 |         {
40 |             Marshal.FreeHGlobal(ptr);
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/Steam/SteamExtensions.cs.uid:
--------------------------------------------------------------------------------
1 | uid://d64qqnr0tln3
2 | 


--------------------------------------------------------------------------------
/Steam/SteamManager.cs:
--------------------------------------------------------------------------------
  1 | using Godot;
  2 | using Steamworks;
  3 | using Steamworks.Data;
  4 | using System;
  5 | using System.Collections.Generic;
  6 | using System.Linq;
  7 | using System.Threading.Tasks;
  8 | 
  9 | namespace Steam;
 10 | public partial class SteamManager : Node
 11 | {
 12 |     [Export]
 13 |     public uint SteamAppId = 480; // replace with your own steam id
 14 | 
 15 |     public event Action<Lobby>? OnLobbySuccessfullyCreated;
 16 |     public event Action<Lobby>? OnLobbyGameCreated;
 17 |     public event Action<Friend>? OnPlayerJoinLobby;
 18 |     public event Action<Friend>? OnPlayerLeftLobby;
 19 |     public event Action<List<Lobby>>? OnLobbyRefreshCompleted;
 20 | 
 21 |     public string PlayerName => SteamClient.Name;
 22 |     public SteamId PlayerSteamID => SteamClient.SteamId;
 23 |     public bool IsHost { get; private set; }
 24 | 
 25 |     private List<Lobby> _availableLobbies = new List<Lobby>();
 26 |     private Lobby _hostedLobby;
 27 |     public override void _Ready()
 28 |     {
 29 |         InstantiateSteam();
 30 | 
 31 |         SteamMatchmaking.OnLobbyGameCreated += OnLobbyGameCreatedWithSteamId;
 32 |         SteamMatchmaking.OnLobbyCreated += OnLobbyCreated;
 33 |         SteamMatchmaking.OnLobbyMemberJoined += OnLobbyMemberJoined;
 34 |         SteamMatchmaking.OnLobbyMemberDisconnected += OnLobbyMemberDisconnected;
 35 |         SteamMatchmaking.OnLobbyMemberLeave += OnLobbyMemberLeave;
 36 |         SteamMatchmaking.OnLobbyEntered += OnLobbyEntered;
 37 |         SteamFriends.OnGameLobbyJoinRequested += OnGameLobbyJoinRequested;
 38 |     }
 39 |     public override void _ExitTree()
 40 |     {
 41 |         SteamClient.Shutdown();
 42 |     }
 43 | 
 44 |     private void OnLobbyMemberDisconnected(Lobby lobby, Friend friend)
 45 |     {
 46 |         OnPlayerLeftLobby?.Invoke(friend);
 47 |     }
 48 | 
 49 |     private void OnLobbyMemberLeave(Lobby lobby, Friend friend)
 50 |     {
 51 |         OnPlayerLeftLobby?.Invoke(friend);
 52 |     }
 53 | 
 54 |     private void OnLobbyMemberJoined(Lobby lobby, Friend friend)
 55 |     {
 56 |         OnPlayerJoinLobby?.Invoke(friend);
 57 |     }
 58 | 
 59 |     private void OnLobbyCreated(Result result, Lobby lobby)
 60 |     {
 61 |         if(result == Result.OK)
 62 |         {
 63 |             OnLobbySuccessfullyCreated?.Invoke(lobby);
 64 |         }
 65 |     }
 66 | 
 67 |     private void OnLobbyGameCreatedWithSteamId(Lobby lobby, uint id, ushort port, SteamId steamId)
 68 |     {
 69 |         OnLobbyGameCreated?.Invoke(lobby);
 70 |     }
 71 |     public async Task CreateLobby()
 72 |     {
 73 |         Lobby? createLobbyOutput = await SteamMatchmaking.CreateLobbyAsync(20);
 74 | 
 75 |         if (!createLobbyOutput.HasValue)
 76 |         {
 77 |             throw new Exception();
 78 |         }
 79 |         _hostedLobby = createLobbyOutput.Value;
 80 |         _hostedLobby.SetPublic();
 81 |         _hostedLobby.SetJoinable(true);
 82 |         _hostedLobby.SetData("ownerNameDataString", PlayerName);
 83 |         IsHost = true;
 84 |     }
 85 |     public async Task GetMultiplayerLobbies()
 86 |     {
 87 |         _availableLobbies = (await SteamMatchmaking.LobbyList.WithMaxResults(10).RequestAsync()).ToList();
 88 | 
 89 |         OnLobbyRefreshCompleted?.Invoke(_availableLobbies);
 90 |     }
 91 |     private void OnLobbyEntered(Lobby lobby)
 92 |     {
 93 |         if (lobby.MemberCount > 0)
 94 |         {
 95 |             _hostedLobby = lobby;
 96 |             foreach (var item in lobby.Members)
 97 |             {
 98 |                 OnPlayerJoinLobby?.Invoke(item);
 99 |             }
100 |             lobby.SetGameServer(lobby.Owner.Id);
101 |         }
102 |     }
103 |     public void LeaveLobby()
104 |     {
105 |         if (IsHost)
106 |         {
107 |             IsHost = false;
108 |         }
109 |         _hostedLobby.Leave();
110 |     }
111 |     private async void OnGameLobbyJoinRequested(Lobby lobby, SteamId id)
112 |     {
113 |         RoomEnter joinSuccessful = await lobby.Join();
114 |         if (joinSuccessful != RoomEnter.Success)
115 |         {
116 |             throw new InvalidOperationException("Failed to Join Lobby");
117 |         }
118 |         else
119 |         {
120 |             _hostedLobby = lobby;
121 | 
122 |             foreach (Friend friend in lobby.Members)
123 |             {
124 |                 OnPlayerJoinLobby?.Invoke(friend);
125 |             }
126 |         }
127 |     }
128 | 
129 |     public void OpenFriendOverlayForInvite()
130 |     {
131 |         SteamFriends.OpenGameInviteOverlay(_hostedLobby.Id);
132 |     }
133 | 
134 |     private void InstantiateSteam()
135 |     {
136 |         try
137 |         {
138 |             SteamClient.Init(SteamAppId, asyncCallbacks: true);
139 |         }
140 |         catch (Exception ex)
141 |         {
142 |             GD.PrintErr(ex.Message);
143 |         }
144 |     }
145 | }
146 | 


--------------------------------------------------------------------------------
/Steam/SteamManager.cs.uid:
--------------------------------------------------------------------------------
1 | uid://b0smp6qoaxdgl
2 | 


--------------------------------------------------------------------------------
/Steam/SteamMultiplayerPeer.cs:
--------------------------------------------------------------------------------
  1 | using Godot;
  2 | using Steamworks;
  3 | using Steamworks.Data;
  4 | using System;
  5 | using System.Collections.Generic;
  6 | using System.Linq;
  7 | 
  8 | namespace Steam;
  9 | public partial class SteamMultiplayerPeer : MultiplayerPeerExtension
 10 | {
 11 |     public enum Mode
 12 |     {
 13 |         None,
 14 |         Server,
 15 |         Client
 16 |     }
 17 | 
 18 |     private const int _maxPacketSize = 524288; // abritrary value from steam. Fun.
 19 | 
 20 |     private SteamConnectionManager? _steamConnectionManager;
 21 |     private SteamSocketManager? _steamSocketManager;
 22 | 
 23 |     private readonly Dictionary<int, SteamConnection> _peerIdToConnection = new Dictionary<int, SteamConnection>();
 24 |     private readonly Dictionary<ulong, SteamConnection> _connectionsBySteamId = new Dictionary<ulong, SteamConnection>();
 25 | 
 26 |     private int _targetPeer = -1;
 27 |     private int _uniqueId = 0;
 28 |     private Mode _mode;
 29 |     private bool _isActive => _mode != Mode.None;
 30 |     private ConnectionStatus _connectionStatus = ConnectionStatus.Disconnected;
 31 |     private TransferModeEnum _transferMode = TransferModeEnum.Reliable;
 32 | 
 33 |     private readonly Queue<SteamPacketPeer> _incomingPackets = new Queue<SteamPacketPeer>();
 34 |     private SteamPacketPeer? _nextReceivedPacket;
 35 | 
 36 |     private SteamId _steamId;
 37 | 
 38 |     private int _transferChannel = 0;
 39 |     private bool _refuseNewConnections = false;
 40 |     public Error CreateHost(SteamId playerId)
 41 |     {
 42 |         _steamId = playerId;
 43 |         if (_isActive)
 44 |         {
 45 |             return Error.AlreadyInUse;
 46 |         }
 47 |         _steamSocketManager = SteamNetworkingSockets.CreateRelaySocket<SteamSocketManager>();
 48 |         _steamConnectionManager = SteamNetworkingSockets.ConnectRelay<SteamConnectionManager>(playerId);
 49 | 
 50 |         _steamSocketManager.OnConnectionEstablished += (c) =>
 51 |         {
 52 |             if (c.Item2.Identity.SteamId != _steamId)
 53 |             {
 54 |                 AddConnection(c.Item2.Identity.SteamId, c.Item1);
 55 |             }
 56 |         };
 57 | 
 58 |         _steamSocketManager.OnConnectionLost += (c) =>
 59 |         {
 60 |             if (c.Item2.Identity.SteamId != _steamId)
 61 |             {
 62 |                 EmitSignal(SignalName.PeerDisconnected, _connectionsBySteamId[c.Item2.Identity.SteamId].PeerId);
 63 |                 _peerIdToConnection.Remove(_connectionsBySteamId[c.Item2.Identity.SteamId].PeerId);
 64 |                 _connectionsBySteamId.Remove(c.Item2.Identity.SteamId);
 65 |             }
 66 |         };
 67 | 
 68 |         _uniqueId = 1;
 69 |         _mode = Mode.Server;
 70 |         _connectionStatus = ConnectionStatus.Connected;
 71 |         return Error.Ok;
 72 |     }
 73 |     public Error CreateClient(SteamId playerId, SteamId hostId)
 74 |     {
 75 |         _steamId = playerId;
 76 |         if (_isActive)
 77 |         {
 78 |             return Error.AlreadyInUse;
 79 |         }
 80 | 
 81 |         _uniqueId = (int)GenerateUniqueId();
 82 | 
 83 |         _steamConnectionManager = SteamNetworkingSockets.ConnectRelay<SteamConnectionManager>(hostId);
 84 | 
 85 |         _steamConnectionManager.OnConnectionEstablished += (connection) =>
 86 |         {
 87 |             if (connection.Identity.SteamId != _steamId)
 88 |             {
 89 |                 AddConnection(connection.Identity.SteamId, _steamConnectionManager.Connection);
 90 |                 _connectionStatus = ConnectionStatus.Connected;
 91 |                 _connectionsBySteamId[connection.Identity.SteamId].SendPeer(_uniqueId);
 92 |             }
 93 |         };
 94 |         _steamConnectionManager.OnConnectionLost += (connection) =>
 95 |         {
 96 |             if (connection.Identity.SteamId != _steamId)
 97 |             {
 98 |                 EmitSignal(SignalName.PeerDisconnected, _connectionsBySteamId[connection.Identity.SteamId].PeerId);
 99 |                 _peerIdToConnection.Remove(_connectionsBySteamId[connection.Identity.SteamId].PeerId);
100 |                 _connectionsBySteamId.Remove(connection.Identity.SteamId);
101 |             }
102 |         };
103 | 
104 |         _mode = Mode.Client;
105 |         _connectionStatus = ConnectionStatus.Connecting;
106 |         return Error.Ok;
107 |     }
108 |     public override void _Close()
109 |     {
110 |         if (!_isActive || _connectionStatus != ConnectionStatus.Connected) { return; }
111 | 
112 |         foreach (var connection in _steamSocketManager?.Connected ?? Enumerable.Empty<Connection>())
113 |         {
114 |             connection.Close();
115 |         }
116 |         if (_IsServer())
117 |         {
118 |             _steamConnectionManager?.Close();
119 |         }
120 | 
121 |         _steamSocketManager?.Close();
122 |         _peerIdToConnection.Clear();
123 |         _connectionsBySteamId.Clear();
124 |         _mode = Mode.None;
125 |         _uniqueId = 0;
126 |         _connectionStatus = ConnectionStatus.Disconnected;
127 |     }
128 |     public override void _DisconnectPeer(int pPeer, bool pForce)
129 |     {
130 |         SteamConnection? connection = GetConnectionFromPeer(pPeer);
131 | 
132 |         if (connection == null) { return; }
133 | 
134 |         bool res = connection.Connection.Close();
135 | 
136 |         if (!res)
137 |         {
138 |             return;
139 |         }
140 | 
141 |         connection.Connection.Flush();
142 |         _connectionsBySteamId.Remove(connection.SteamId);
143 |         _peerIdToConnection.Remove(pPeer);
144 |         if (_mode == Mode.Client || _mode == Mode.Server)
145 |         {
146 |             GetConnectionFromPeer(0)?.Connection.Flush();
147 |         }
148 |         if (pForce && _mode == Mode.Client)
149 |         {
150 |             _connectionsBySteamId.Clear();
151 |             Close();
152 |         }
153 |     }
154 | 
155 |     public override int _GetAvailablePacketCount()
156 |     {
157 |         return _incomingPackets.Count;
158 |     }
159 | 
160 |     public override ConnectionStatus _GetConnectionStatus()
161 |     {
162 |         return _connectionStatus;
163 |     }
164 | 
165 |     public override int _GetMaxPacketSize()
166 |     {
167 |         return _maxPacketSize;
168 |     }
169 | 
170 |     public override int _GetPacketChannel()
171 |     {
172 |         return 0; // todo - implement more channels
173 |     }
174 | 
175 |     public override TransferModeEnum _GetPacketMode()
176 |     {
177 |         return _incomingPackets.FirstOrDefault()?.TransferMode ?? TransferModeEnum.Reliable;
178 |     }
179 | 
180 |     public override int _GetPacketPeer()
181 |     {
182 |         return _connectionsBySteamId[_incomingPackets.FirstOrDefault()?.SenderSteamId ?? 0].PeerId;
183 |     }
184 |     public override byte[] _GetPacketScript()
185 |     {
186 |         if (_incomingPackets.TryDequeue(out SteamPacketPeer? packet))
187 |         {
188 |             return packet.Data;
189 |         }
190 | 
191 |         return [];
192 |     }
193 | 
194 | 
195 |     public override int _GetTransferChannel()
196 |     {
197 |         return _transferChannel;
198 |     }
199 | 
200 |     public override TransferModeEnum _GetTransferMode()
201 |     {
202 |         return _transferMode;
203 |     }
204 | 
205 |     public override int _GetUniqueId()
206 |     {
207 |         return _uniqueId;
208 |     }
209 | 
210 |     public override bool _IsRefusingNewConnections()
211 |     {
212 |         return _refuseNewConnections;
213 |     }
214 | 
215 |     public override bool _IsServer()
216 |     {
217 |         return _uniqueId == 1;
218 |     }
219 | 
220 |     public override bool _IsServerRelaySupported()
221 |     {
222 |         return _mode == Mode.Server || _mode == Mode.Client;
223 |     }
224 |     public override void _Poll()
225 |     {
226 |         if (_steamSocketManager != null)
227 |         {
228 |             _steamSocketManager.Receive();
229 |         }
230 | 
231 |         if (_steamConnectionManager != null && _steamConnectionManager.Connected)
232 |         {
233 |             _steamConnectionManager.Receive();
234 |         }
235 | 
236 |         IEnumerable<SteamNetworkingMessage> steamNetworkingMessages = _steamConnectionManager?.GetPendingMessages() ?? [];
237 | 
238 |         foreach (SteamConnection connection in _connectionsBySteamId.Values)
239 |         {
240 |             IEnumerable<SteamNetworkingMessage> messagesByConnection = steamNetworkingMessages.Union(_steamSocketManager?.ReceiveMessagesOnConnection(connection.Connection) ?? []);
241 |             foreach (SteamNetworkingMessage message in messagesByConnection)
242 |             {
243 |                 if (GetPeerIdFromSteamId(message.Sender) != -1)
244 |                 {
245 |                     ProcessMesssage(message);
246 |                 }
247 |                 else
248 |                 {
249 |                     SteamConnection.SetupPeerPayload? receive = message.Data.ToStruct<SteamConnection.SetupPeerPayload>();
250 | 
251 |                     ProcessPing(receive.Value, message.Sender);
252 |                 }
253 |             }
254 |         }
255 |     }
256 | 
257 |     private void ProcessPing(SteamConnection.SetupPeerPayload receive, ulong sender)
258 |     {
259 |         SteamConnection connection = _connectionsBySteamId[sender];
260 | 
261 |         if (receive.PeerId != -1)
262 |         {
263 |             if (connection.PeerId == -1)
264 |             {
265 |                 SetSteamIdPeer(sender, receive.PeerId);
266 |             }
267 |             if (_IsServer())
268 |             {
269 |                 connection.SendPeer(_uniqueId);
270 |             }
271 | 
272 |             EmitSignal(SignalName.PeerConnected, receive.PeerId);
273 |         }
274 |     }
275 | 
276 |     private void SetSteamIdPeer(ulong steamId, int peerId)
277 |     {
278 |         SteamConnection steamConnection = _connectionsBySteamId[steamId];
279 |         if (steamConnection.PeerId == -1)
280 |         {
281 |             steamConnection.PeerId = peerId;
282 |             _peerIdToConnection.Add(peerId, steamConnection);
283 |         }
284 |     }
285 | 
286 |     private void ProcessMesssage(SteamNetworkingMessage message)
287 |     {
288 |         SteamPacketPeer packet = new SteamPacketPeer(message.Data, TransferModeEnum.Reliable);
289 |         packet.SenderSteamId = message.Sender;
290 | 
291 |         _incomingPackets.Enqueue(packet);
292 |     }
293 | 
294 |     public override Error _PutPacketScript(byte[] pBuffer)
295 |     {
296 |         if (!_isActive || _connectionStatus != ConnectionStatus.Connected) { return Error.Unconfigured; }
297 | 
298 |         if (_targetPeer != 0 && !_peerIdToConnection.ContainsKey(Mathf.Abs(_targetPeer)))
299 |         {
300 |             return Error.InvalidParameter;
301 |         }
302 | 
303 |         if (_mode == Mode.Client && !_peerIdToConnection.ContainsKey(1))
304 |         {
305 |             return Error.Bug;
306 |         }
307 | 
308 |         SteamPacketPeer packet = new SteamPacketPeer(pBuffer, _transferMode);
309 | 
310 | 
311 |         if (_targetPeer == 0)
312 |         {
313 |             Error error = Error.Ok;
314 |             foreach (SteamConnection connection in _connectionsBySteamId.Values)
315 |             {
316 |                 Error packetSendingError = connection.Send(packet);
317 | 
318 |                 if (packetSendingError != Error.Ok)
319 |                 {
320 |                     return packetSendingError;
321 |                 }
322 |             }
323 |             return error;
324 |         }
325 |         else
326 |         {
327 |             return GetConnectionFromPeer(_targetPeer)?.Send(packet) ?? Error.Unavailable;
328 |         }
329 |     }
330 | 
331 |     public override void _SetRefuseNewConnections(bool pEnable)
332 |     {
333 |         _refuseNewConnections = pEnable;
334 |     }
335 | 
336 |     public override void _SetTargetPeer(int pPeer)
337 |     {
338 |         _targetPeer = pPeer;
339 |     }
340 | 
341 |     public override void _SetTransferChannel(int pChannel)
342 |     {
343 |         _transferChannel = pChannel;
344 |     }
345 | 
346 |     public override void _SetTransferMode(TransferModeEnum pMode)
347 |     {
348 |         _transferMode = pMode;
349 |     }
350 | 
351 |     private SteamConnection? GetConnectionFromPeer(int peerId)
352 |     {
353 |         if (_peerIdToConnection.TryGetValue(peerId, out SteamConnection? value))
354 |         {
355 |             return value;
356 |         }
357 |         return null;
358 |     }
359 |     private int GetPeerIdFromSteamId(ulong steamId)
360 |     {
361 |         if (steamId == _steamId.Value)
362 |         {
363 |             return _uniqueId;
364 |         }
365 |         else if (_connectionsBySteamId.TryGetValue(steamId, out SteamConnection? value))
366 |         {
367 |             return value.PeerId;
368 |         }
369 |         else
370 |         {
371 |             return -1;
372 |         }
373 |     }
374 | 
375 |     private void AddConnection(SteamId steamId, Connection connection)
376 |     {
377 |         if (steamId == _steamId.Value)
378 |         {
379 |             throw new InvalidOperationException("Cannot add Self as Peer");
380 |         }
381 |         SteamConnection connectionData = new SteamConnection
382 |         {
383 |             Connection = connection,
384 |             SteamIdRaw = steamId
385 |         };
386 |         _connectionsBySteamId.Add(steamId, connectionData);
387 |     }
388 | }


--------------------------------------------------------------------------------
/Steam/SteamMultiplayerPeer.cs.uid:
--------------------------------------------------------------------------------
1 | uid://yvweytprc3nj
2 | 


--------------------------------------------------------------------------------
/Steam/SteamNetworkingMessage.cs:
--------------------------------------------------------------------------------
 1 | using static Godot.MultiplayerPeer;
 2 | using Steamworks;
 3 | 
 4 | namespace Steam;
 5 | public class SteamNetworkingMessage
 6 | {
 7 |     public SteamNetworkingMessage(byte[] data, SteamId sender, TransferModeEnum transferMode, long receiveTime)
 8 |     {
 9 |         Data = data;
10 |         Sender = sender;
11 |         TransferMode = transferMode;
12 |         ReceiveTime = receiveTime;
13 | 
14 |     }
15 | 
16 |     public byte[] Data { get; private set; }
17 |     public SteamId Sender { get; private set; }
18 | 
19 |     public TransferModeEnum TransferMode { get; private set; }
20 | 
21 |     public int Size => Data.Length;
22 | 
23 |     public long ReceiveTime { get; private set; }
24 | 
25 | }


--------------------------------------------------------------------------------
/Steam/SteamNetworkingMessage.cs.uid:
--------------------------------------------------------------------------------
1 | uid://bvril6h6r6lb4
2 | 


--------------------------------------------------------------------------------
/Steam/SteamPacketPeer.cs:
--------------------------------------------------------------------------------
 1 | using Godot;
 2 | using static Godot.MultiplayerPeer;
 3 | 
 4 | namespace Steam;
 5 | public partial class SteamPacketPeer : RefCounted
 6 | {
 7 |     public SteamPacketPeer(byte[] data, TransferModeEnum transferMode = TransferModeEnum.Reliable)
 8 |     {
 9 |         Data = data;
10 |         TransferMode = transferMode;
11 |     }
12 | 
13 |     public byte[] Data { get; private set; }
14 |     public ulong SenderSteamId { get; set; }
15 |     public TransferModeEnum TransferMode { get; private set; }
16 | }
17 | 


--------------------------------------------------------------------------------
/Steam/SteamPacketPeer.cs.uid:
--------------------------------------------------------------------------------
1 | uid://drkelywlwnoya
2 | 


--------------------------------------------------------------------------------
/Steam/SteamSocketManager.cs:
--------------------------------------------------------------------------------
 1 | using Godot;
 2 | using Steamworks.Data;
 3 | using Steamworks;
 4 | using System;
 5 | using System.Runtime.InteropServices;
 6 | using System.Collections.Generic;
 7 | using System.Linq;
 8 | 
 9 | namespace Steam;
10 | public class SteamSocketManager : SocketManager
11 | {
12 |     private Dictionary<Connection, Queue<SteamNetworkingMessage>> _connectionMessages = new Dictionary<Connection, Queue<SteamNetworkingMessage>>();
13 | 
14 |     public event Action<(Connection, ConnectionInfo)>? OnConnectionEstablished;
15 |     public event Action<(Connection, ConnectionInfo)>? OnConnectionLost;
16 |     public event Action<(Connection, ConnectionInfo)>? OnConnectionChange;
17 | 
18 |     public override void OnConnectionChanged(Connection connection, ConnectionInfo info)
19 |     {
20 |         base.OnConnectionChanged(connection, info);
21 |         OnConnectionChange?.Invoke((connection, info));
22 |     }
23 |     public override void OnConnected(Connection connection, ConnectionInfo info)
24 |     {
25 |         base.OnConnected(connection, info);
26 |         _connectionMessages.Add(connection, new Queue<SteamNetworkingMessage>());
27 |         OnConnectionEstablished?.Invoke((connection, info));
28 |     }
29 | 
30 |     public override void OnConnecting(Connection connection, ConnectionInfo info)
31 |     {
32 |         base.OnConnecting(connection, info);
33 |     }
34 | 
35 |     public override void OnDisconnected(Connection connection, ConnectionInfo info)
36 |     {
37 |         base.OnDisconnected(connection, info);
38 |         _connectionMessages.Remove(connection);
39 |         OnConnectionLost?.Invoke((connection, info));
40 |     }
41 | 
42 |     public override void OnMessage(Connection connection, NetIdentity identity, IntPtr data, int size, long recvTime, long messageNum, int channel)
43 |     {
44 |         base.OnMessage(connection, identity, data, size, messageNum, recvTime, channel);
45 | 
46 |         byte[] managedArray = new byte[size];
47 |         Marshal.Copy(data, managedArray, 0, size);
48 | 
49 |         _connectionMessages[connection].Enqueue(new SteamNetworkingMessage(managedArray, identity.SteamId, MultiplayerPeer.TransferModeEnum.Reliable, recvTime));
50 |     }
51 | 
52 |     public IEnumerable<SteamNetworkingMessage> ReceiveMessagesOnConnection(Connection connection)
53 |     {
54 |         int messageCount = _connectionMessages[connection].Count;
55 |         for (int i = 0; i < messageCount; i++)
56 |         {
57 |             yield return _connectionMessages[connection].Dequeue();
58 |         }
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/Steam/SteamSocketManager.cs.uid:
--------------------------------------------------------------------------------
1 | uid://bqisj6m3nomel
2 | 


--------------------------------------------------------------------------------
/SteamMultiplayerPeer.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Godot.NET.Sdk/4.4.0">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>net8.0</TargetFramework>
 4 |     <EnableDynamicLoading>true</EnableDynamicLoading>
 5 |     <Nullable>enable</Nullable>
 6 |     <Company>Mason Adams</Company>
 7 |     <Authors>Mason Adams</Authors>
 8 |     <PackageReadmeFile>README.md</PackageReadmeFile>
 9 |     <PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
10 |     <RepositoryUrl>https://github.com/Pieeer1/SteamMultiplayerPeer</RepositoryUrl>
11 |   </PropertyGroup>
12 |   <ItemGroup>
13 | 	  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
14 | 	  <PackageReference Include="gdUnit4.api" Version="4.2.1" />
15 | 	  <PackageReference Include="gdUnit4.test.adapter" Version="1.0.0" />
16 | 	</ItemGroup>
17 |   <ItemGroup>
18 | 	<None Include=".runsettings" />
19 | 	<None Include=".runsettings-ci" />
20 |   </ItemGroup>
21 |   <ItemGroup>
22 |     <None Include="Facepunch/Facepunch.Steamworks.Posix.dll" />
23 |     <None Include="Facepunch/Facepunch.Steamworks.Win64.dll" />
24 |     <None Include="steam_api.dll">
25 |       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
26 |       <Pack>true</Pack>
27 |       <PackagePath>lib/net8.0</PackagePath>
28 |     </None>
29 |     <None Include="steam_api64.dll">
30 |       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
31 |       <Pack>true</Pack>
32 |       <PackagePath>lib/net8.0</PackagePath>
33 |     </None>
34 |   </ItemGroup>
35 |   <ItemGroup>
36 |     <Reference Include="Facepunch.Steamworks.Win64" Condition="$([MSBuild]::IsOSPlatform('Windows'))">
37 |       <HintPath>./Facepunch/Facepunch.Steamworks.Win64.dll</HintPath>
38 |       <Pack>true</Pack>
39 |       <PackagePath>lib/net8.0</PackagePath>
40 |     </Reference>
41 |     <Reference Include="Facepunch.Steamworks.Win64" Condition="$([MSBuild]::IsOSPlatform('Linux'))">
42 |       <HintPath>./Facepunch/Facepunch.Steamworks.Posix.dll</HintPath>
43 |       <Pack>true</Pack>
44 |       <PackagePath>lib/net8.0</PackagePath>
45 |     </Reference>
46 |     <Reference Include="Facepunch.Steamworks.Win64" Condition="$([MSBuild]::IsOSPlatform('OSX'))">
47 |       <HintPath>./Facepunch/Facepunch.Steamworks.Posix.dll</HintPath>
48 |       <Pack>true</Pack>
49 |       <PackagePath>lib/net8.0</PackagePath>
50 |     </Reference>
51 |     <None Include="README.md" Pack="true" PackagePath="\" />
52 |     <None Include="LICENSE.txt" Pack="true" PackagePath="" />
53 |   </ItemGroup>
54 | </Project>


--------------------------------------------------------------------------------
/SteamMultiplayerPeer.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.9.34607.119
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SteamMultiplayerPeer", "SteamMultiplayerPeer.csproj", "{2DFA2ECF-826E-4A07-A84C-F4D1A2889AC5}"
 7 | EndProject
 8 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{423D8126-6408-4A6F-890C-B828A7E01884}"
 9 | 	ProjectSection(SolutionItems) = preProject
10 | 		.gitignore = .gitignore
11 | 		.github\actions\godot-install\action.yml = .github\actions\godot-install\action.yml
12 | 		.github\workflows\build_test_deploy.yml = .github\workflows\build_test_deploy.yml
13 | 		.github\version\GitVersion.yml = .github\version\GitVersion.yml
14 | 	EndProjectSection
15 | EndProject
16 | Global
17 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
18 | 		Debug|Any CPU = Debug|Any CPU
19 | 		ExportDebug|Any CPU = ExportDebug|Any CPU
20 | 		ExportRelease|Any CPU = ExportRelease|Any CPU
21 | 	EndGlobalSection
22 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
23 | 		{2DFA2ECF-826E-4A07-A84C-F4D1A2889AC5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
24 | 		{2DFA2ECF-826E-4A07-A84C-F4D1A2889AC5}.Debug|Any CPU.Build.0 = Debug|Any CPU
25 | 		{2DFA2ECF-826E-4A07-A84C-F4D1A2889AC5}.ExportDebug|Any CPU.ActiveCfg = ExportDebug|Any CPU
26 | 		{2DFA2ECF-826E-4A07-A84C-F4D1A2889AC5}.ExportDebug|Any CPU.Build.0 = ExportDebug|Any CPU
27 | 		{2DFA2ECF-826E-4A07-A84C-F4D1A2889AC5}.ExportRelease|Any CPU.ActiveCfg = ExportRelease|Any CPU
28 | 		{2DFA2ECF-826E-4A07-A84C-F4D1A2889AC5}.ExportRelease|Any CPU.Build.0 = ExportRelease|Any CPU
29 | 	EndGlobalSection
30 | 	GlobalSection(SolutionProperties) = preSolution
31 | 		HideSolutionNode = FALSE
32 | 	EndGlobalSection
33 | 	GlobalSection(ExtensibilityGlobals) = postSolution
34 | 		SolutionGuid = {61571D42-83BF-4713-B662-7BDCBDD2BC8A}
35 | 	EndGlobalSection
36 | EndGlobal
37 | 


--------------------------------------------------------------------------------
/Tests/SteamManagerTests.cs:
--------------------------------------------------------------------------------
  1 | using Steam;
  2 | using Steamworks;
  3 | using Steamworks.Data;
  4 | using System;
  5 | using System.Threading.Tasks;
  6 | 
  7 | namespace SteamMultiplayerPeer.Tests;
  8 | [TestSuite]
  9 | public class SteamManagerTests
 10 | {
 11 |     private SteamManager _steamManager;
 12 |     public SteamManagerTests()
 13 |     {
 14 |         _steamManager = new SteamManager();
 15 |         _steamManager._Ready();
 16 | 
 17 |         if (!SteamClient.IsValid)
 18 |         {
 19 |             throw new Exception("Error: Steam Connection Failed: Make sure Steam is running for these tests to run. Unfortunately this is a limitation");
 20 |         }
 21 |     }
 22 | 
 23 | 
 24 |     [TestCase]
 25 |     public void Test_SteamManager_Initialize()
 26 |     {
 27 |         AssertThat(_steamManager.PlayerName).IsNotNull();
 28 |         AssertThat(_steamManager.PlayerSteamID != 0).IsTrue();
 29 |     }
 30 | 
 31 |     [TestCase]
 32 |     public async Task Test_SteamManager_InitializeLobby()
 33 |     {
 34 |         int successfullyCreatedLobbyCount = 0;
 35 |         int lobbyGameCreatedCount = 0;
 36 |         int playerJoinLobbyCount = 0;
 37 |         int playerLeftLobbyCount = 0;
 38 | 
 39 |         _steamManager.OnLobbySuccessfullyCreated += (l) => successfullyCreatedLobbyCount++;
 40 |         _steamManager.OnLobbyGameCreated += (l) => lobbyGameCreatedCount++;
 41 |         _steamManager.OnPlayerJoinLobby += (f) => playerJoinLobbyCount++;
 42 |         _steamManager.OnPlayerLeftLobby += (f) => playerLeftLobbyCount++;
 43 | 
 44 |         await _steamManager.CreateLobby();
 45 | 
 46 |         AssertThat(_steamManager.IsHost).IsTrue();
 47 | 
 48 |         Lobby lobby = (Lobby)typeof(SteamManager).GetField("_hostedLobby", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)!.GetValue(_steamManager)!;
 49 |         AssertThat(lobby.Owner.Id == _steamManager.PlayerSteamID).IsTrue();
 50 |         AssertThat(successfullyCreatedLobbyCount).Equals(1);
 51 |         AssertThat(lobbyGameCreatedCount).Equals(0);
 52 |         AssertThat(playerJoinLobbyCount).Equals(0);
 53 |         AssertThat(playerLeftLobbyCount).Equals(0);
 54 | 
 55 |     }
 56 |     [TestCase]
 57 |     public async Task Test_SteamManager_JoinLobby()
 58 |     {
 59 |         int successfullyCreatedLobbyCount = 0;
 60 |         int lobbyGameCreatedCount = 0;
 61 |         int playerJoinLobbyCount = 0;
 62 |         int playerLeftLobbyCount = 0;
 63 | 
 64 |         _steamManager.OnLobbySuccessfullyCreated += (l) => successfullyCreatedLobbyCount++;
 65 |         _steamManager.OnLobbyGameCreated += (l) => lobbyGameCreatedCount++;
 66 |         _steamManager.OnPlayerJoinLobby += (f) => playerJoinLobbyCount++;
 67 |         _steamManager.OnPlayerLeftLobby += (f) => playerLeftLobbyCount++;
 68 |  
 69 |         await _steamManager.CreateLobby();
 70 | 
 71 |         AssertThat(_steamManager.IsHost).IsTrue();
 72 | 
 73 |         Lobby lobby = (Lobby)typeof(SteamManager).GetField("_hostedLobby", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)!.GetValue(_steamManager)!;
 74 |         AssertThat(lobby.Owner.Id == _steamManager.PlayerSteamID).IsTrue();
 75 |         AssertThat(successfullyCreatedLobbyCount).Equals(1);
 76 |         AssertThat(lobbyGameCreatedCount).Equals(0);
 77 |         AssertThat(playerJoinLobbyCount).Equals(0);
 78 |         AssertThat(playerLeftLobbyCount).Equals(0);
 79 | 
 80 |         SteamManager joiningSteamManager = new SteamManager();
 81 | 
 82 |         await lobby.Join();
 83 | 
 84 |         AssertThat(joiningSteamManager.IsHost).IsFalse();
 85 |         AssertThat(successfullyCreatedLobbyCount).Equals(1);
 86 |         AssertThat(lobbyGameCreatedCount).Equals(0);
 87 |         AssertThat(playerJoinLobbyCount).Equals(1);
 88 |         AssertThat(playerLeftLobbyCount).Equals(0);
 89 |     }
 90 | 
 91 |     [TestCase]
 92 |     public async Task Test_SteamManager_SelfLeaveLobby()
 93 |     {
 94 |         int successfullyCreatedLobbyCount = 0;
 95 |         int lobbyGameCreatedCount = 0;
 96 |         int playerJoinLobbyCount = 0;
 97 |         int playerLeftLobbyCount = 0;
 98 | 
 99 |         _steamManager.OnLobbySuccessfullyCreated += (l) => successfullyCreatedLobbyCount++;
100 |         _steamManager.OnLobbyGameCreated += (l) => lobbyGameCreatedCount++;
101 |         _steamManager.OnPlayerJoinLobby += (f) => playerJoinLobbyCount++;
102 |         _steamManager.OnPlayerLeftLobby += (f) => playerLeftLobbyCount++;
103 | 
104 |         await _steamManager.CreateLobby();
105 | 
106 |         AssertThat(_steamManager.IsHost).IsTrue();
107 | 
108 |         Lobby lobby = (Lobby)typeof(SteamManager).GetField("_hostedLobby", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)!.GetValue(_steamManager)!;
109 |         AssertThat(lobby.Owner.Id == _steamManager.PlayerSteamID).IsTrue();
110 |         AssertThat(successfullyCreatedLobbyCount).Equals(1);
111 |         AssertThat(lobbyGameCreatedCount).Equals(0);
112 |         AssertThat(playerJoinLobbyCount).Equals(0);
113 |         AssertThat(playerLeftLobbyCount).Equals(0);
114 | 
115 |         _steamManager.LeaveLobby();
116 | 
117 |         AssertThat(_steamManager.IsHost).IsFalse();
118 |         AssertThat(successfullyCreatedLobbyCount).Equals(1);
119 |         AssertThat(lobbyGameCreatedCount).Equals(0);
120 |         AssertThat(playerJoinLobbyCount).Equals(0);
121 |         AssertThat(playerLeftLobbyCount).Equals(0);
122 |     }
123 |     [TestCase]
124 |     public async Task Test_SteamManager_JoinAndLeaveLobby()
125 |     {
126 |         int successfullyCreatedLobbyCount = 0;
127 |         int lobbyGameCreatedCount = 0;
128 |         int playerJoinLobbyCount = 0;
129 |         int playerLeftLobbyCount = 0;
130 | 
131 |         _steamManager.OnLobbySuccessfullyCreated += (l) => successfullyCreatedLobbyCount++;
132 |         _steamManager.OnLobbyGameCreated += (l) => lobbyGameCreatedCount++;
133 |         _steamManager.OnPlayerJoinLobby += (f) => playerJoinLobbyCount++;
134 |         _steamManager.OnPlayerLeftLobby += (f) => playerLeftLobbyCount++;
135 | 
136 |         await _steamManager.CreateLobby();
137 | 
138 |         AssertThat(_steamManager.IsHost).IsTrue();
139 | 
140 |         Lobby lobby = (Lobby)typeof(SteamManager).GetField("_hostedLobby", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)!.GetValue(_steamManager)!;
141 |         AssertThat(lobby.Owner.Id == _steamManager.PlayerSteamID).IsTrue();
142 |         AssertThat(successfullyCreatedLobbyCount).Equals(1);
143 |         AssertThat(lobbyGameCreatedCount).Equals(0);
144 |         AssertThat(playerJoinLobbyCount).Equals(0);
145 |         AssertThat(playerLeftLobbyCount).Equals(0);
146 | 
147 |         SteamManager joiningSteamManager = new SteamManager();
148 | 
149 |         await lobby.Join();
150 | 
151 |         AssertThat(joiningSteamManager.IsHost).IsFalse();
152 |         AssertThat(successfullyCreatedLobbyCount).Equals(1);
153 |         AssertThat(lobbyGameCreatedCount).Equals(0);
154 |         AssertThat(playerJoinLobbyCount).Equals(1);
155 |         AssertThat(playerLeftLobbyCount).Equals(0);
156 | 
157 |         lobby.Leave();
158 | 
159 |         AssertThat(_steamManager.IsHost).IsTrue();
160 |         AssertThat(joiningSteamManager.IsHost).IsFalse();
161 |         AssertThat(successfullyCreatedLobbyCount).Equals(1);
162 |         AssertThat(lobbyGameCreatedCount).Equals(0);
163 |         AssertThat(playerJoinLobbyCount).Equals(1);
164 |         AssertThat(playerLeftLobbyCount).Equals(1);
165 |     }
166 | }
167 | 


--------------------------------------------------------------------------------
/Tests/SteamManagerTests.cs.uid:
--------------------------------------------------------------------------------
1 | uid://cggircag50uvy
2 | 


--------------------------------------------------------------------------------
/Tests/Usings.cs:
--------------------------------------------------------------------------------
1 | global using GdUnit4;
2 | global using Godot;
3 | global using static GdUnit4.Assertions;


--------------------------------------------------------------------------------
/Tests/Usings.cs.uid:
--------------------------------------------------------------------------------
1 | uid://dr5ijqxbwoaae
2 | 


--------------------------------------------------------------------------------
/icon.svg:
--------------------------------------------------------------------------------
1 | <svg height="128" width="128" xmlns="http://www.w3.org/2000/svg"><rect x="2" y="2" width="124" height="124" rx="14" fill="#363d52" stroke="#212532" stroke-width="4"/><g transform="scale(.101) translate(122 122)"><g fill="#fff"><path d="M105 673v33q407 354 814 0v-33z"/><path fill="#478cbf" d="m105 673 152 14q12 1 15 14l4 67 132 10 8-61q2-11 15-15h162q13 4 15 15l8 61 132-10 4-67q3-13 15-14l152-14V427q30-39 56-81-35-59-83-108-43 20-82 47-40-37-88-64 7-51 8-102-59-28-123-42-26 43-46 89-49-7-98 0-20-46-46-89-64 14-123 42 1 51 8 102-48 27-88 64-39-27-82-47-48 49-83 108 26 42 56 81zm0 33v39c0 276 813 276 813 0v-39l-134 12-5 69q-2 10-14 13l-162 11q-12 0-16-11l-10-65H447l-10 65q-4 11-16 11l-162-11q-12-3-14-13l-5-69z"/><path d="M483 600c3 34 55 34 58 0v-86c-3-34-55-34-58 0z"/><circle cx="725" cy="526" r="90"/><circle cx="299" cy="526" r="90"/></g><g fill="#414042"><circle cx="307" cy="532" r="60"/><circle cx="717" cy="532" r="60"/></g></g></svg>
2 | 


--------------------------------------------------------------------------------
/icon.svg.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="CompressedTexture2D"
 5 | uid="uid://bm3lcw48d0win"
 6 | path="res://.godot/imported/icon.svg-218a8f2b3041327d8a5756f3a245f83b.ctex"
 7 | metadata={
 8 | "vram_texture": false
 9 | }
10 | 
11 | [deps]
12 | 
13 | source_file="res://icon.svg"
14 | dest_files=["res://.godot/imported/icon.svg-218a8f2b3041327d8a5756f3a245f83b.ctex"]
15 | 
16 | [params]
17 | 
18 | compress/mode=0
19 | compress/high_quality=false
20 | compress/lossy_quality=0.7
21 | compress/hdr_compression=1
22 | compress/normal_map=0
23 | compress/channel_pack=0
24 | mipmaps/generate=false
25 | mipmaps/limit=-1
26 | roughness/mode=0
27 | roughness/src_normal=""
28 | process/fix_alpha_border=true
29 | process/premult_alpha=false
30 | process/normal_map_invert_y=false
31 | process/hdr_as_srgb=false
32 | process/hdr_clamp_exposure=false
33 | process/size_limit=0
34 | detect_3d/compress_to=1
35 | svg/scale=1.0
36 | editor/scale_with_editor_scale=false
37 | editor/convert_colors_with_editor_theme=false
38 | 


--------------------------------------------------------------------------------
/project.godot:
--------------------------------------------------------------------------------
 1 | ; Engine configuration file.
 2 | ; It's best edited using the editor UI and not directly,
 3 | ; since the parameters that go here are not all obvious.
 4 | ;
 5 | ; Format:
 6 | ;   [section] ; section goes between []
 7 | ;   param=value ; assign values to parameters
 8 | 
 9 | config_version=5
10 | 
11 | [application]
12 | 
13 | config/name="SteamMultiplayerPeer"
14 | run/main_scene="res://Example/Startup.tscn"
15 | config/features=PackedStringArray("4.4", "C#", "Forward Plus")
16 | config/icon="res://icon.svg"
17 | 
18 | [dotnet]
19 | 
20 | project/assembly_name="SteamMultiplayerPeer"
21 | 


--------------------------------------------------------------------------------
/steam_api.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Pieeer1/SteamMultiplayerPeer/59b47989a40f8c728add74c9a0fb8fbbd07fafce/steam_api.dll


--------------------------------------------------------------------------------
/steam_api64.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Pieeer1/SteamMultiplayerPeer/59b47989a40f8c728add74c9a0fb8fbbd07fafce/steam_api64.dll


--------------------------------------------------------------------------------