Compare commits

..

493 Commits

Author SHA1 Message Date
MarcEricMartel
535d6f7745 Fair enough 2023-12-18 15:26:44 -05:00
MarcEricMartel
40e90fe12d !!!!!!!!!!! 2023-12-18 15:24:06 -05:00
MarcEricMartel
6076b55267 HP! 2023-12-18 15:12:15 -05:00
MarcEricMartel
f799e689d2 woups 2023-12-18 14:54:14 -05:00
MarcEricMartel
6d07285f43 Test pickup 2023-12-18 14:50:18 -05:00
MarcEricMartel
25b5c1e492 oooooooooo 2023-12-18 14:24:43 -05:00
MarcEricMartel
f1bb7447f9 almoos dere 2023-12-18 13:29:38 -05:00
MarcEricMartel
68d03c1eac Merge branch 'SQC19_Booster' into online_boosts 2023-12-18 11:19:52 -05:00
MarcEricMartel
cf831e339f Ça s'ra pas long. Non non non non non. 2023-12-18 11:18:42 -05:00
MarcEricMartel
9a669acd9c !!!! 2023-12-18 11:10:10 -05:00
MarcEricMartel
2c346139d5 Merge branch 'master' of git.frereschasseurs.studio:memartel_loc/SQCSimulator2023 2023-12-18 07:47:08 -05:00
MarcEricMartel
82747990d9
Merge pull request #43 from CegepSTH/SQC-15_online
Sqc 15 online
2023-12-16 16:56:31 -05:00
MarcEricMartel
0782f37e0a Might as well jump, JUMP! 2023-12-16 16:43:25 -05:00
MarcEricMartel
75f745efb8 Update player.cpp 2023-12-16 16:23:47 -05:00
MarcEricMartel
6efda6122d LETS TRY WITHOUT DAS JOOMP 2023-12-16 16:21:25 -05:00
MarcEricMartel
678776d6e6 Remove the dead code. 2023-12-16 16:13:20 -05:00
MarcEricMartel
4df53a5f9b Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-16 15:52:47 -05:00
MarcEricMartel
90892ce7d3 pop. 2023-12-16 15:52:39 -05:00
Claudel-D-Roy
5e1e8366ce j'push des choses 2023-12-16 15:52:27 -05:00
MarcEricMartel
7f9462881c Oops, all changes! 2023-12-16 15:27:20 -05:00
MarcEricMartel
2eacc0477b ?! 2023-12-16 15:15:25 -05:00
MarcEricMartel
745f40bc37 REVERT. 2023-12-16 15:11:48 -05:00
MarcEricMartel
ba6b383251 erratum 2023-12-16 15:05:26 -05:00
MarcEricMartel
1065357e70 Eh? 2023-12-16 15:05:06 -05:00
MarcEricMartel
4a4f353250 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-16 14:41:07 -05:00
MarcEricMartel
63d1f997ca blob 2023-12-16 14:41:01 -05:00
Claudel-D-Roy
da94565c3e EL NIINIOOO 2023-12-16 14:41:00 -05:00
Frederic Leger
f2c5f8b636 booster fonctionnel
manque la distribution booster sur la map
2023-12-16 14:38:01 -05:00
MarcEricMartel
1c2a691638 Bullet Time is slow. 2023-12-16 14:01:08 -05:00
MarcEricMartel
7803f46a6b WE ARE THE WORLD. 2023-12-16 13:14:37 -05:00
MarcEricMartel
38bab49806 Log de se faire tirer 2023-12-16 13:05:04 -05:00
MarcEricMartel
547d0fb3f8 Ça devrait crier moins 2023-12-16 12:57:04 -05:00
MarcEricMartel
dec9da6395 no more whoosh 2023-12-16 12:48:08 -05:00
MarcEricMartel
f564e37544 YYYAAAAAAARRRGGHH? 2023-12-16 12:32:54 -05:00
MarcEricMartel
ca1ab7301d Merge branch 'master' into SQC-15_online 2023-12-16 12:09:23 -05:00
Claudel-D-Roy
7a7ba94cbd Merge branch 'RepairWhoosh' 2023-12-16 12:09:04 -05:00
MarcEricMartel
ac50a044c7 Merge branch 'master' into SQC-15_online 2023-12-16 12:06:41 -05:00
MarcEricMartel
8062d8e31d lol 2023-12-16 12:05:57 -05:00
MarcEricMartel
4d278dfdea Pow pow t'es mow. 2023-12-16 12:05:14 -05:00
MarcEricMartel
da9fd2477d Update documents 2023-12-16 09:32:42 -05:00
Frederic Leger
2364fb9c1f booster quasi fonctionnel
affichage seulement visible a travers un autre booster.
ne se ramasse pas encore.
2023-12-15 23:02:20 -05:00
Frederic Leger
570bef266c merge conflict 2023-12-15 15:40:13 -05:00
MarcEricMartel
de8fe3c1c5 Merge branch 'master' into SQC-15_online 2023-12-15 07:13:16 -05:00
MarcEricMartel
5ee3fd143b Update engine.cpp 2023-12-15 07:11:35 -05:00
MarcEricMartel
77a982b1fa
Merge pull request #41 from CegepSTH/ConnexionVariablesMenuOptions
Connexion variables menu options
2023-12-15 07:02:09 -05:00
MarcEricMartel
e4316e7d8d Mis le son qui joue après que le volume soit changé pour les contrôles de volume 2023-12-15 06:39:18 -05:00
mduval76
935a977bdf Push options resolution fonctionnels. 2023-12-14 21:20:21 -05:00
mduval76
82bae1c21a Push background transparent pour menu options Graphics 2023-12-14 20:34:59 -05:00
mduval76
58c06f9f84 Push menu Lobby pour single player (entree du username seulement) 2023-12-14 19:33:25 -05:00
MarcEricMartel
8e77565bb4 Merge branch 'master' into SQC-15_online 2023-12-14 19:17:37 -05:00
mduval76
e5b0c742dd Push back button dans le lobbymenu 2023-12-14 18:25:15 -05:00
MarcEricMartel
1af88ba3e3 correction sfx 2023-12-14 14:02:29 -05:00
mduval76
383a19cbd2 Push mainvolume et musicvolume sliders fonctionnels. Bug sfx 2023-12-14 00:08:07 -05:00
mduval76
67270a0b21 Push options volume musique modifiable fonctionnel 2023-12-13 19:59:01 -05:00
mduval76
b101add0e7 Push sans les logs. 2023-12-13 19:13:02 -05:00
mduval76
0a0c70883b Push avec sensibilité souris - version fusionnée au master courant. 2023-12-13 19:12:22 -05:00
mduval76
879f93e2cd Validation des changements indexes... 2023-12-13 19:08:07 -05:00
mduval76
f7934be7f9 push ajustement de mp3 a wav pour sons 2023-12-13 19:02:17 -05:00
mduval76
0b4546eee9 Push sensibilite souris fonctionnelle. 2023-12-13 17:50:15 -05:00
mduval76
6ba316aa2d Push mouse sensitivity 2023-12-13 17:15:58 -05:00
Claudel-D-Roy
bb247d0afe Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 16:32:49 -05:00
Claudel-D-Roy
26d03ca5cc horriblé 2023-12-13 16:32:43 -05:00
MarcEricMartel
b8899b8f86 NO CHEATING! 2023-12-13 16:30:20 -05:00
MarcEricMartel
325c6b60f9 keep in sync when dead 2023-12-13 16:29:13 -05:00
MarcEricMartel
7b350fa403 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 16:10:34 -05:00
MarcEricMartel
71691c55c8 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 16:10:25 -05:00
MarcEricMartel
49374a7dea Let's all die! 2023-12-13 16:10:23 -05:00
Claudel-D-Roy
5a3ce00cb2 kjhg 2023-12-13 16:10:21 -05:00
Claudel-D-Roy
136f589975 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 15:45:25 -05:00
Claudel-D-Roy
6d4f592278 k. 2023-12-13 15:45:17 -05:00
MarcEricMartel
37a86d42a3 lol infinite loop 2023-12-13 15:29:12 -05:00
Rynort
a08a6c7db3 Update doc_dev.docx 2023-12-13 15:25:48 -05:00
MarcEricMartel
2f3260b16a Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 15:23:20 -05:00
MarcEricMartel
08204934c8 No more 1. 2023-12-13 15:23:14 -05:00
Claudel-D-Roy
74875709af Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 15:21:36 -05:00
Claudel-D-Roy
28dc760cba potatoes 2023-12-13 15:21:23 -05:00
MarcEricMartel
c7c38ed44d Suicide is NOT the answer. 2023-12-13 15:21:19 -05:00
Claudel-D-Roy
53e0af3f94 PUSHING STUFF INTO THE VOID 2023-12-13 15:18:17 -05:00
Claudel-D-Roy
a11c52cf77 AH BEN TABARNOUCHE 2023-12-13 15:14:38 -05:00
MarcEricMartel
b1fc9d7d92 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 15:04:10 -05:00
MarcEricMartel
a85c5cc626 🔫 2023-12-13 15:04:08 -05:00
Claudel-D-Roy
4c3803c02e pleurer en animation 2023-12-13 14:46:53 -05:00
MarcEricMartel
5e09305398 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 14:27:18 -05:00
MarcEricMartel
fd1fe66d13 SYNC_ACC CMOD_ACC GLOBALS 2023-12-13 14:27:11 -05:00
Claudel-D-Roy
edebad86a6 Blahblahblah 2023-12-13 14:26:46 -05:00
MarcEricMartel
2dbaf84844 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 14:06:29 -05:00
MarcEricMartel
e31e670720 Yaya 2023-12-13 14:06:22 -05:00
Claudel-D-Roy
d8cbc27ca9 ALLO 2023-12-13 14:06:11 -05:00
Claudel-D-Roy
c801877a0c polipocket 2023-12-13 13:53:10 -05:00
Claudel-D-Roy
f4347d35df secret 2023-12-13 13:51:37 -05:00
MarcEricMartel
f509b01827 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 13:47:41 -05:00
MarcEricMartel
18d6d58203 There's a bullet without my name on it. 2023-12-13 13:47:34 -05:00
Claudel-D-Roy
83fc600ce2 l;kjhgfd 2023-12-13 13:46:57 -05:00
Claudel-D-Roy
0e45b2b81e essaie no. 89657657457 2023-12-13 13:33:44 -05:00
Claudel-D-Roy
d3c6353f17 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-13 13:18:28 -05:00
Claudel-D-Roy
8fbb92ec5b ghfudk 2023-12-13 13:17:29 -05:00
MarcEricMartel
64655856e9 gniah. 2023-12-13 13:13:34 -05:00
MarcEricMartel
a6b6ac870a Update sync plus vite. 2023-12-13 13:01:52 -05:00
MarcEricMartel
5ef6ab5006 Merge branch 'master' into SQC-15_online 2023-12-13 12:57:41 -05:00
MarcEricMartel
7ffccc8bf8 woups^2 2023-12-13 12:39:24 -05:00
MarcEricMartel
c9ebfd348c woups 2023-12-13 12:38:19 -05:00
Claudel-D-Roy
ae247a58a8 Merge branch 'SQC_MenuMusic' 2023-12-13 12:15:39 -05:00
MarcEricMartel
2f53f74ca9 Erratum 2 2023-12-13 11:21:42 -05:00
MarcEricMartel
3d0b35123a Erratum 2023-12-13 11:11:14 -05:00
MarcEricMartel
aacfb880f0 + son de clic quand on clique. 2023-12-13 10:55:58 -05:00
Jonathan Trottier
6c68114fbb
Merge pull request #39 from CegepSTH/PauseMenuFieldsAndOnline
Beaucoup de belles choses
2023-12-12 19:28:28 -05:00
MarcEricMartel
b840e3ad19 Erratum 2023-12-12 09:31:56 -05:00
MarcEricMartel
7a30e43001 Merge branch 'SQC-15_online' into PauseMenuFieldsAndOnline 2023-12-12 09:31:01 -05:00
mduval76
c099a3b8eb Push menu pause fonctionnel 2023-12-11 21:41:40 -05:00
MarcEricMartel
7498076d7a Corrections timer 2023-12-11 07:31:20 -05:00
MarcEricMartel
7c1f70646a Correction bug de switch de fullscreen 2023-12-11 05:35:29 -05:00
4255830d4f Merge pull request 'SQC-15_online' (#1) from SQC-15_online into master
Reviewed-on: https://git.frereschasseurs.studio/memartel_loc/SQCSimulator2023/pulls/1
2023-12-10 17:41:24 -05:00
MarcEricMartel
5b0be2d985 Gossage de musique 2023-12-09 16:51:43 -05:00
MarcEricMartel
c176fddea1 Update engine.cpp 2023-12-09 16:25:24 -05:00
MarcEricMartel
46298f8256 Oh yeah. 2023-12-09 15:54:06 -05:00
MarcEricMartel
461a8aa11b Merge remote-tracking branch 'origin/InputFields' into SQC_mergeFieldsAndOnline 2023-12-09 15:23:44 -05:00
MarcEricMartel
9aaad6426c 🚫 👂 🐆 2023-12-09 12:02:04 -05:00
mduval76
09979f1e72 Push connexion multiplayer. 2023-12-09 00:00:52 -05:00
mduval76
c88143c2bc Push inputs username et server address fonctionnels. 2023-12-08 23:42:01 -05:00
mduval76
ff10207257 Push backspace fonctionnel 2023-12-08 23:06:33 -05:00
mduval76
06cd890506 Push input rejette touches non valides. 2023-12-08 22:34:17 -05:00
mduval76
850f5a59d8 Push string accumule comme il faut 2023-12-08 22:15:10 -05:00
mduval76
9562dc00b8 Push SimulateKeyboard différencie MAJ et MIN 2023-12-08 21:45:19 -05:00
mduval76
d6b1870b5b Push fake keyboard - Simulatekeyboard 2023-12-08 19:55:59 -05:00
MarcEricMartel
63d70be488 Make player spawn point random working? 2023-12-08 05:07:05 -05:00
MarcEricMartel
3da68297e4 Cleanup + client. 2023-12-08 04:58:27 -05:00
MarcEricMartel
34976ef7ec /* delete[] mess */ Well there's your mem leak. 2023-12-08 04:55:00 -05:00
MarcEricMartel
7d46536acc Can now clean bullets off the forest. 2023-12-08 04:31:10 -05:00
mduval76
721fef57e2 Push lobby labels. 2023-12-07 16:31:43 -05:00
MarcEricMartel
7e98eeb852 whyyyyyyyyy 2023-12-07 15:47:31 -05:00
MarcEricMartel
db95c6ef10 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-07 15:14:24 -05:00
MarcEricMartel
486c823da1 OH 2023-12-07 15:14:16 -05:00
Claudel-D-Roy
fcd1c869b9 Enlever les commentaires 2023-12-07 15:13:45 -05:00
MarcEricMartel
8bfee4a9ff :Q 2023-12-07 14:24:09 -05:00
Claudel-D-Roy
58c97587bf Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-07 14:04:38 -05:00
Claudel-D-Roy
d1f02c34e9 FaCkInG HeLL 2023-12-07 14:04:31 -05:00
MarcEricMartel
ab87da7d88 Ehm. 2023-12-07 14:03:58 -05:00
mduval76
c66e49ab0c Push de quoi 2023-12-07 13:55:44 -05:00
MarcEricMartel
33bcdea06f IT'S LEAKING! 2023-12-07 13:34:58 -05:00
MarcEricMartel
4d44d57a5a Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-07 13:06:00 -05:00
MarcEricMartel
f6c5379a8c °Oo. 2023-12-07 13:05:52 -05:00
Claudel-D-Roy
bc865dd9b5 Bacon ‼️ 2023-12-07 13:05:21 -05:00
MarcEricMartel
5696e20452 Gériboire! 2023-12-07 12:51:17 -05:00
MarcEricMartel
4e0a9cea35 Crosby, Still, Jump and Shoot 2023-12-07 12:48:48 -05:00
MarcEricMartel
f0afdf828e Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-07 12:43:49 -05:00
MarcEricMartel
11458214d0 Update connection.cpp 2023-12-07 12:43:40 -05:00
Claudel-D-Roy
1905c31923 Push && Pull 2023-12-07 12:43:16 -05:00
MarcEricMartel
99a5054c8f Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-07 12:32:45 -05:00
MarcEricMartel
74b808f46b Jump and Shoot! 🎶 2023-12-07 12:32:36 -05:00
Claudel-D-Roy
0a08a22c60 Jump && shoot 2023-12-07 12:31:04 -05:00
Claudel-D-Roy
4e287702c3 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-07 12:22:58 -05:00
Claudel-D-Roy
3e8497f43b 💫 2023-12-07 12:22:49 -05:00
MarcEricMartel
e9e2a56be6 OOPS I DID IT AGAIN. I PLAYED WITH THE CODE, GOT LOST IN THE MORT. 2023-12-07 12:21:21 -05:00
MarcEricMartel
b7b6a8cc7b I hurt myself today ... because of the serveur. 2023-12-07 12:15:57 -05:00
MarcEricMartel
948597361f Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-07 12:10:56 -05:00
MarcEricMartel
76256115d1 Oh là là. 2023-12-07 12:10:47 -05:00
Claudel-D-Roy
1d48242147 Update remoteplayer.cpp 2023-12-07 12:10:17 -05:00
Claudel-D-Roy
18f08feb68 2023-12-06 17:02:36 -05:00
Claudel-D-Roy
57bfacf942 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-06 16:49:34 -05:00
Claudel-D-Roy
51bd6440f0 JUMPSHOOT 2023-12-06 16:49:26 -05:00
MarcEricMartel
c8c82770b7 Mr. Clean? 2023-12-06 16:48:53 -05:00
MarcEricMartel
84249ef84c YÉ TÔRD 2023-12-06 16:42:09 -05:00
MarcEricMartel
cb0dad3e31 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-06 16:36:29 -05:00
MarcEricMartel
e8a475419f 2112 by PUSH. 2023-12-06 16:36:21 -05:00
Claudel-D-Roy
9eac62c44a 🚷 2023-12-06 16:35:39 -05:00
MarcEricMartel
481b5a284c skibidi 🚽 2023-12-06 16:23:09 -05:00
Claudel-D-Roy
d80281231b 🚽 2023-12-06 16:22:05 -05:00
Claudel-D-Roy
8eb2de4cd9 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-06 16:21:06 -05:00
MarcEricMartel
d1805f2309 Pleurer en chat. 2023-12-06 16:20:59 -05:00
Claudel-D-Roy
89fafb100e Pleurer en animation 2023-12-06 16:20:52 -05:00
MarcEricMartel
449e12ca5a GOT THE TIME TICK TICK TICKIN' IN MY HEAD 2023-12-06 16:01:29 -05:00
MarcEricMartel
9924c12ccd Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-06 15:52:08 -05:00
MarcEricMartel
0fb5c85660 Everything is false. 2023-12-06 15:52:00 -05:00
Claudel-D-Roy
bf0306f018 👊 2023-12-06 15:51:55 -05:00
MarcEricMartel
db854c77b2 👌 2023-12-06 15:47:14 -05:00
MarcEricMartel
7077b617be Rollover Beethoven 2023-12-06 15:37:08 -05:00
MarcEricMartel
6178604d95 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-06 14:49:45 -05:00
MarcEricMartel
a60156bf2c badaboum 2023-12-06 14:49:36 -05:00
Claudel-D-Roy
2596a35af4 Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-06 14:31:13 -05:00
MarcEricMartel
242250f251 Oh oh oh oh oh!!! 2023-12-06 14:31:05 -05:00
Claudel-D-Roy
a79bf0d1eb 🚍 2023-12-06 14:31:04 -05:00
MarcEricMartel
42ea83d73e Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-06 13:50:00 -05:00
MarcEricMartel
59d3060444 eh? 2023-12-06 13:49:59 -05:00
Claudel-D-Roy
dc61488809 cout out 2023-12-06 13:49:11 -05:00
MarcEricMartel
58a1f5437a Merge branch 'SQC-15_online' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_online 2023-12-06 13:46:50 -05:00
MarcEricMartel
f835853605 Chamone 2023-12-06 13:46:43 -05:00
Claudel-D-Roy
3760e140ae HiiIIIiiiIiI 2023-12-06 13:46:24 -05:00
MarcEricMartel
64b40023aa Ah ben lol. 2023-12-06 13:43:33 -05:00
MarcEricMartel
c47b36726b :> 2023-12-06 13:42:15 -05:00
MarcEricMartel
1762043757 Bonne idée. 2023-12-06 13:23:33 -05:00
mduval76
63d8a62429 Push tin toé 2023-12-06 13:14:51 -05:00
MarcEricMartel
3b0f9650d4 What a big mess. 2023-12-06 12:32:26 -05:00
MarcEricMartel
adf36c8905 Whooooooooo are you? 2023-12-06 12:25:34 -05:00
MarcEricMartel
f29abe8046 Merge branch 'master' into SQC-15_online 2023-12-06 12:18:01 -05:00
MarcEricMartel
988b2c330c Before the merge.... 2023-12-06 12:17:47 -05:00
MarcEricMartel
4841e8d5ba Make Debug Great Again 2023-12-06 12:08:44 -05:00
MarcEricMartel
6c7369a8be Merge branch 'RUNNINGREALLYFAST' into SQC-15_online 2023-12-06 11:19:02 -05:00
MarcEricMartel
c975265901 Timer iznogoud. 2023-12-06 11:16:39 -05:00
Claudel-D-Roy
7a7dc1fad6 DomoAriGato 2023-12-06 11:16:30 -05:00
Claudel-D-Roy
0856f913d2 yay 2023-12-06 10:48:04 -05:00
MarcEricMartel
9c1cd885cf Tehe. 2023-12-05 15:02:31 -05:00
MarcEricMartel
b11a484a5a 😎 2023-12-05 14:25:21 -05:00
MarcEricMartel
464ba131c4 Corrections merge de master
hell.
2023-12-05 13:44:54 -05:00
MarcEricMartel
4775de01d8 Merge branch 'master' into SQC-15_online 2023-12-05 06:34:51 -05:00
MarcEricMartel
e8a0f7e4fb
Merge pull request #38 from CegepSTH/Améloration_Gen_Monde
Améloration gen monde
2023-12-05 06:29:41 -05:00
MarcEricMartel
2446b90bff bulletadd 2023-12-05 06:25:48 -05:00
Claudel-D-Roy
16e9f6aefe GG le push 2023-12-04 19:05:36 -05:00
Rynort
d9152a721c Création de la dock 2023-12-04 17:41:05 -05:00
Louis-CharlesG
2c73a2ed00 Correction des arbres. 2023-12-04 17:17:15 -05:00
Claudel-D-Roy
e98bd03192 GG EN ROTATION 2023-12-04 17:02:15 -05:00
Claudel-D-Roy
e6e93ef6d0 YAY 2023-12-04 16:45:46 -05:00
Louis-CharlesG
d444b4de30 Re-Changement des textures. 2023-12-04 16:17:59 -05:00
Louis-CharlesG
bb100fd5cb ajustement texture. 2023-12-04 16:12:02 -05:00
Louis-CharlesG
a137666546 Merge branch 'master' into Améloration_Gen_Monde 2023-12-04 15:44:22 -05:00
Louis-CharlesG
841947bc7a Changment pour lac/arbre 2023-12-04 15:05:27 -05:00
MarcEricMartel
bc5c28a373
Merge pull request #34 from CegepSTH/MenusMenusMenus
Menus menus menus
2023-12-04 13:25:55 -05:00
MarcEricMartel
754130ec39
Merge pull request #36 from CegepSTH/revert-35-SQC-15_paquets
Revert "IGNORE THIS"
2023-12-04 13:16:03 -05:00
MarcEricMartel
8569e17c93
Revert "IGNORE THIS" 2023-12-04 13:14:54 -05:00
MarcEricMartel
c5700ae9fd
Merge pull request #35 from CegepSTH/SQC-15_paquets
IGNORE THIS
2023-12-04 13:14:33 -05:00
MarcEricMartel
78b3ed85cb
Merge branch 'MenusMenusMenus' into SQC-15_paquets 2023-12-04 13:13:54 -05:00
mduval76
4b6c641c97 Push replacer Render 2023-12-04 13:02:28 -05:00
MarcEricMartel
9ed8ef3273 Moar random? 2023-12-03 11:14:08 -05:00
mduval76
8b448f5072 Push pre-gamestate Pause 2023-12-03 00:47:04 -05:00
mduval76
a67499049b Push gros paquets de menus. Nouvelle hierarchie Clean up de larborescence des textures pour elements des menus. 2023-12-03 00:15:18 -05:00
Claudel-D-Roy
df0a142b12 ishhh 2023-12-02 15:19:46 -05:00
MarcEricMartel
0af76b3f2e
Merge pull request #33 from CegepSTH/SQC32_sauveParams
Sqc32 sauve params
2023-12-02 15:09:14 -05:00
MarcEricMartel
b2c73c930e
Merge pull request #32 from CegepSTH/SQC-35_nouvelles_structures
Sqc 35 nouvelles structures
2023-12-02 14:59:21 -05:00
MarcEricMartel
4aa0aedd61 Update connector.cpp 2023-12-02 14:52:25 -05:00
MarcEricMartel
e52dbd3705 Merge branch 'master' into SQC-15_paquets 2023-12-02 14:05:41 -05:00
MarcEricMartel
5a491c5446 omg 💣 2023-12-02 11:05:00 -05:00
MarcEricMartel
20eb410b08 Hahaha il manquait les ChunkMods dans netprot :finnadie: 2023-12-02 10:04:18 -05:00
MarcEricMartel
c44d1453ae Oh wow 2023-12-02 09:23:26 -05:00
MarcEricMartel
37ea09aaf3 Merge branch 'SQC-15_paquets' of https://github.com/CegepSTH/SQCSim2023 into SQC-15_paquets 2023-12-02 09:06:54 -05:00
MarcEricMartel
62b7719eb4 Erratas! 2023-12-02 09:06:41 -05:00
mduval76
3842ca3485 Push bouton pour retourner au menu principal. Makeover des anciens boutons. 2023-12-01 20:26:52 -05:00
mduval76
98390c878f Push pourcentage dynamique pour sliders menu options 2023-12-01 19:20:55 -05:00
mduval76
def1ab284e Push sliders fonctionnels (x4) 2023-12-01 17:55:25 -05:00
mduval76
90e736a14c push ajouts des barres pour "sliders" 2023-12-01 15:46:08 -05:00
mduval76
ac3628ec0b Push zones cliquables sliders et checks 2023-12-01 14:37:12 -05:00
mduval76
3e3a7650e8 Push options Volume et Resolution de base 2023-12-01 13:48:48 -05:00
mduval76
28082a018d Push menu options de base 2023-12-01 09:49:00 -05:00
681ac61a74 ajouts dans les cmakelists pour leenuqs 2023-11-29 19:02:16 -05:00
38cfa95297 ajouts dans les cmakelists pour leenuqs 2023-11-29 18:59:58 -05:00
34ad4724f2 Tibug + Linux 2023-11-28 19:19:24 -05:00
MarcEricMartel
12ef911e79 Delete the world... delete the children... 2023-11-28 11:53:21 -05:00
MarcEricMartel
5c346c48e6 🏥 2023-11-28 11:38:38 -05:00
MarcEricMartel
e89b5914fb Sync ees almöss de voork! 2023-11-27 17:44:52 -05:00
mduval76
15882dc506 Merge branch 'master' into SQC32_sauveParams 2023-11-27 17:14:53 -05:00
mduval76
6db90a3a16 Push reajustements apres merge 31 2023-11-27 17:07:51 -05:00
mduval76
b23b2c6838
Merge pull request #31 from CegepSTH/SQC-31
Sqc 31 smerge
2023-11-27 16:55:31 -05:00
mduval76
a26929fe66
Merge branch 'master' into SQC-31 2023-11-27 16:54:58 -05:00
Louis-CharlesG
e3b59e37eb Les arbres avec le seed. 2023-11-27 16:47:10 -05:00
MarcEricMartel
10b8d77734 ehm 2023-11-27 16:43:18 -05:00
MarcEricMartel
e8ca08ecab Superman + Alfred 2023-11-27 16:12:12 -05:00
mduval76
4a9ad70d48 Push changement pour Parametres -> Settings 2023-11-27 16:03:06 -05:00
Jonathan Trottier
e330f5dd67 Merge branch 'master' into SQC-35_nouvelles_structures 2023-11-27 15:58:34 -05:00
Jonathan Trottier
2f5579875e little modif 2023-11-27 15:57:31 -05:00
Jonathan Trottier
114c1631a8 randomness no more random 2023-11-27 15:56:47 -05:00
MarcEricMartel
cfc7f7e01d Ça s'ra pas long. 2023-11-27 15:15:21 -05:00
MarcEricMartel
0b5c30b693 123457 💯 2023-11-27 15:03:53 -05:00
MarcEricMartel
f9c3571ab2 1080p 2023-11-27 14:56:43 -05:00
MarcEricMartel
2a7fe7e806 LA CLAN PANNETON POUR DÉMÉNAGER FAUT SIGNALER LE (/&)&)&! 2023-11-27 14:53:23 -05:00
MarcEricMartel
8ea5af6ef9 16 tons. 2023-11-27 14:48:18 -05:00
MarcEricMartel
841b0176f6 HAHAHAHA HEY! MOSKAU MOSKAU BADDABADBADBABDBAD 2023-11-27 14:42:56 -05:00
MarcEricMartel
702a65c5b0 EEEEEEEH BO DEREK, EH 2023-11-27 14:24:11 -05:00
MarcEricMartel
b6d5975648 I know what boys like. 2023-11-27 13:52:49 -05:00
MarcEricMartel
6e556b4f84 IDBENOGOOD 2023-11-27 13:29:59 -05:00
MarcEricMartel
e6b3f2fb1c UDP to the rescue 2023-11-27 13:21:50 -05:00
MarcEricMartel
5e57a13820 Fuck around and find out 2023-11-27 13:15:39 -05:00
MarcEricMartel
9a7d25c1d9 EH LALA. 2023-11-27 13:11:24 -05:00
MarcEricMartel
c24123362a ah. 2023-11-27 12:42:46 -05:00
MarcEricMartel
6c0d65ea22 Info. 2023-11-27 12:39:36 -05:00
Rynort
9bb8b1c9e5 Ajout de la page Option
Pas de bouton encore
2023-11-27 02:57:22 -05:00
MarcEricMartel
35a5ddd9bd static_cast? 2023-11-26 12:40:08 -05:00
MarcEricMartel
85ab712032 Summary (required) 2023-11-26 12:31:17 -05:00
MarcEricMartel
0f1a864282 🎶 If you want to destroy my renderrrrrrrrrr... 2023-11-26 12:23:17 -05:00
MarcEricMartel
0200f77be8 Johnny B. NoGood! 🎶 2023-11-26 12:19:05 -05:00
MarcEricMartel
935216e9c3 Ça plane pour pasmoi. 2023-11-26 12:12:09 -05:00
mduval76
1ab83a85a7 Transfert classe Paramteres de common à SQCSim 2021 2023-11-25 14:05:47 -05:00
mduval76
2ab201e93c Validation changements indexes. Fusion main vers sauveparams 2023-11-25 13:59:51 -05:00
MarcEricMartel
ea3d2ffc34 2023-11-24 15:56:58 -05:00
MarcEricMartel
775c8cf26f 440hz 2023-11-24 15:32:53 -05:00
MarcEricMartel
0c1714dd14 INXS 2023-11-24 15:25:40 -05:00
MarcEricMartel
981d66c730 M*SYNCs 2023-11-24 15:24:46 -05:00
MarcEricMartel
bd3f677118 PATATE PLAY 2023-11-24 15:11:16 -05:00
MarcEricMartel
35c55f2e26 -__- 2023-11-24 15:01:32 -05:00
MarcEricMartel
9bf5188e0f 5 2023-11-24 14:54:38 -05:00
MarcEricMartel
e8d456cc09 -danse de la pluie- 2023-11-24 14:36:55 -05:00
MarcEricMartel
3043b1ff6b débébitter 2023-11-24 14:33:48 -05:00
MarcEricMartel
7ccecdfd4a if notaire break. 2023-11-24 14:27:11 -05:00
MarcEricMartel
6f13e8fb70 🔡 2023-11-24 14:22:05 -05:00
MarcEricMartel
d1c3d17055 ayoye bobo 2023-11-24 14:18:37 -05:00
MarcEricMartel
573316682b Jim Babwe 2023-11-24 14:15:40 -05:00
MarcEricMartel
bd14cd3962 Cleanup II 2023-11-24 13:47:47 -05:00
MarcEricMartel
480521ebaf Cleanup 2023-11-24 13:47:24 -05:00
MarcEricMartel
312542857a united states of remoteplayer 2023-11-24 13:46:16 -05:00
MarcEricMartel
c1aa321f2b 💩 2023-11-24 13:42:53 -05:00
MarcEricMartel
d7bd36d134 DE 🐛 2023-11-24 13:05:17 -05:00
MarcEricMartel
ce2d03c354 Render other players 2023-11-24 12:58:06 -05:00
MarcEricMartel
2e30995f1b Merge branch 'SQC-15_animation' into SQC-15_paquets 2023-11-24 12:46:04 -05:00
Claudel-D-Roy
9572a7d6fd push des textures Atlas des animations 2023-11-24 12:45:17 -05:00
MarcEricMartel
f22c405915 Erratum. 2023-11-24 12:43:09 -05:00
MarcEricMartel
bc7127ef7d Eh baswell 2023-11-24 12:41:20 -05:00
MarcEricMartel
06a5bb67d3 :clock: côté client 2023-11-24 12:36:01 -05:00
Rynort
83e438583f Avancement Page Option 2023-11-20 17:34:39 -05:00
Claudel-D-Roy
3600e597e6 Modif 2023-11-20 16:53:35 -05:00
Claudel-D-Roy
38a6c26407 Modif de booster 2023-11-20 16:51:36 -05:00
Frederic Leger
e2ff55603d Merge branch 'master' of https://github.com/CegepSTH/SQCSim2023 2023-11-20 16:28:14 -05:00
Frederic Leger
49b90509b9 ajustement booster 2023-11-20 16:27:59 -05:00
MarcEricMartel
14be450f09 🎶 You spin me right round, baby, right round, like a record, baby, right round, round, round 🎶 2023-11-20 16:27:19 -05:00
Claudel-D-Roy
279ea6072f 🚑 2023-11-20 16:19:12 -05:00
Claudel-D-Roy
488fe55410
Merge pull request #30 from CegepSTH/SQC-35_nouvelles_structures
Sqc 35 nouvelles structures
2023-11-20 16:12:33 -05:00
Jonathan Trottier
f7bfa8a81e Merge branch 'master' into SQC-35_nouvelles_structures 2023-11-20 16:05:29 -05:00
Jonathan Trottier
3118f71b9c ajout de billot de bois 2023-11-20 16:02:45 -05:00
MarcEricMartel
6855e50144
Merge pull request #29 from CegepSTH/SQC19_Booster
Sqc19 booster
2023-11-20 15:56:23 -05:00
Rynort
75a32270b5 mini-push 2023-11-20 15:45:08 -05:00
Frederic Leger
3a38753d8e Merge branch 'master' into SQC19_Booster 2023-11-20 15:43:01 -05:00
Frederic Leger
8769aa9e38 booster affiche
affiche simplement un carre rouge pour l'instant et ne se ramasse pas encore
2023-11-20 15:40:43 -05:00
Louis-CharlesG
732f74de91 Changement dans le chunk a ajout des arbes avec le seed. 2023-11-20 15:39:11 -05:00
Claudel-D-Roy
547772b2f9
Merge pull request #28 from CegepSTH/SQC-15_paquets
Sqc 15 paquets
2023-11-20 15:31:30 -05:00
MarcEricMartel
a91e5dcf5e OUaip 2023-11-20 15:20:20 -05:00
Claudel-D-Roy
02fafea45c Push de couleur qui marche pas 💢 2023-11-20 15:02:02 -05:00
Claudel-D-Roy
85b8f4b94b Ajout des TextureAtlas et affichage de RemotePlayer 2023-11-20 14:28:54 -05:00
Frederic Leger
225c815da4 Merge branch 'SQC-15_animation' into SQC19_Booster 2023-11-20 12:15:28 -05:00
Claudel-D-Roy
4751b2350a Biggest ReSeizing Ever On Earth 2023-11-19 19:37:28 -05:00
MarcEricMartel
8860593740 :godmode: ENFIN SANT-CALISSE DE CRISS 2023-11-19 16:46:13 -05:00
Claudel-D-Roy
82cfc2d1b1 pleurer en rotation 2023-11-18 14:16:24 -05:00
mduval76
8e041a314d Push premiere esquisse des parametres de sauvegarde 2023-11-16 23:39:44 -05:00
mduval76
6bb3ee9667 push changement de location 2023-11-16 20:47:20 -05:00
mduval76
f654c5effa Push initial pour sauvegarde des paramètres 2023-11-16 18:01:00 -05:00
Claudel-D-Roy
dc0d2d8148 Merge branch 'SQC-15_paquets' into SQC-15_animation 2023-11-15 11:35:03 -05:00
MarcEricMartel
86536fbb99 Maintenant je comprend les singes au début de 2001 A Space Odyssey 2023-11-15 08:27:51 -05:00
Claudel-D-Roy
9426af39e7 push triste du quad qui marche pas 2023-11-14 22:17:00 -05:00
Rynort
3ca941f0ce Update engine.cpp 2023-11-13 17:20:33 -05:00
MarcEricMartel
e011e2f1fc Merge remote-tracking branch 'origin/SQC-15_animation' into SQC-15_paquets 2023-11-13 17:02:39 -05:00
MarcEricMartel
bb810ba1c1
Merge pull request #27 from CegepSTH/master
Reverse pr
2023-11-13 16:55:21 -05:00
MarcEricMartel
71852738c1 Merge branch 'master' into SQC-15_paquets 2023-11-13 16:51:27 -05:00
MarcEricMartel
fedd150461
Merge pull request #26 from CegepSTH/SQC-33_Retrecissage_du_monde
correction
2023-11-13 16:48:02 -05:00
MarcEricMartel
cfb9b56ee8
Merge pull request #25 from CegepSTH/SQC-33_Retrecissage_du_monde
rétrécissement du monde
2023-11-13 16:46:49 -05:00
MarcEricMartel
c98625a610 correction 2023-11-13 16:46:03 -05:00
Claudel-D-Roy
dfd2ddc8af push de test pour les animations 2023-11-13 16:02:13 -05:00
Rynort
4c695fbe47 mini changement 2023-11-13 15:42:04 -05:00
MarcEricMartel
a4a99ed425
Merge pull request #24 from CegepSTH/SQC-22
Sqc 22
2023-11-10 18:36:31 -05:00
Jonathan Trottier
80a5bf90b4 rétrécissement du monde 2023-11-08 10:32:16 -05:00
MarcEricMartel
e5e3c19137 🕐 Implémentation de la synchro basique. 2023-11-07 07:56:59 -05:00
MarcEricMartel
8bd46ba831 Receiving 📦 2023-11-07 07:46:11 -05:00
MarcEricMartel
bc1f4f750b heum well 2023-11-06 17:59:57 -05:00
MarcEricMartel
253e49b1cc DOMO ARIGATO, MISUTA ROBOTO :trollface: 2023-11-06 16:43:52 -05:00
Rynort
cd921b3ab3 Réparation du Merge du Pause 2023-11-06 16:04:34 -05:00
MarcEricMartel
ef7851bebf
Merge branch 'master' into SQC-22 2023-11-06 15:39:54 -05:00
MarcEricMartel
d49d5cdebc ehm 2023-11-06 14:07:38 -05:00
MarcEricMartel
9b9e2b3f1f Poll McSocket 2023-11-06 13:56:12 -05:00
MarcEricMartel
ac9174f793 Envoi des millis avec les Inputs 2023-11-02 15:47:15 -04:00
f51305bd11 O_o' 2023-11-02 11:52:49 -04:00
MarcEricMartel
13ba82d09e on enlève le ouach. 2023-11-01 16:45:38 -04:00
MarcEricMartel
2753e41d34 😠 2023-11-01 16:40:33 -04:00
MarcEricMartel
408679433b wtf?! 2023-11-01 15:02:41 -04:00
MarcEricMartel
5cf5eb132a 📼 2023-11-01 12:40:38 -04:00
MarcEricMartel
ab84e42c72 un tipeu de cleanup 2023-11-01 12:18:27 -04:00
MarcEricMartel
0ef437600d Merge branch 'master' into SQC-15_paquets 2023-11-01 10:14:05 -04:00
MarcEricMartel
6e47bdc8a4 Comments 2023-11-01 10:13:10 -04:00
Jonathan Trottier
79013fe5d1
Merge pull request #21 from CegepSTH/SQC_21_MenuSoloMulti
Push menu solo ou multi.
2023-11-01 10:04:30 -04:00
MarcEricMartel
88acc268b8 🐶 2023-11-01 09:19:26 -04:00
MarcEricMartel
e5d9eb2fa6 Erratum 2023-11-01 08:59:09 -04:00
MarcEricMartel
ccad131370 Merge branch 'master' into SQC-15_paquets 2023-11-01 06:27:02 -04:00
MarcEricMartel
11e8684ee0
Merge pull request #23 from CegepSTH/SQC-54_MenuBackGround
Sqc 54 menu back ground
2023-11-01 06:20:44 -04:00
MarcEricMartel
6570ce1302 *laugh maniacally* 2023-11-01 06:17:58 -04:00
MarcEricMartel
88a8553608 *guttural scream* 2023-11-01 06:12:38 -04:00
MarcEricMartel
48078182a1 ser/deser toch dood, wat nou? 2023-10-31 15:30:07 -04:00
MarcEricMartel
3db59a876c ser/deser dood, wat nou? 2023-10-31 15:28:10 -04:00
MarcEricMartel
78f7974f1c OH YEAH. 2023-10-31 15:06:03 -04:00
MarcEricMartel
553ef01765 ptit cleanup 2023-10-31 14:40:38 -04:00
MarcEricMartel
54307b7c17 Le seed est pas bon, mais ON A LES DROITS! 2023-10-31 14:38:30 -04:00
mduval76
9dd2e1b821 Fix pour resize dynamique de la fenetre de jeu (positionnement et scalaires).
Fix pour le maudit F10-fullscreen
2023-10-31 11:11:14 -04:00
MarcEricMartel
eb7116bac8 BUFFER_LENGTH 2023-10-30 17:22:21 -04:00
MarcEricMartel
f44b6cd7dc y tho 2023-10-30 16:57:12 -04:00
Frederic Leger
3e89035de5 Merge branch 'master' into SQC-54_MenuBackGround 2023-10-30 16:21:16 -04:00
Louis-Charles Gaumond
0c8772edbf Changer l'image background du menu 2023-10-30 15:52:15 -04:00
Rynort
e5189f437c Finission du code pour le Pause 2023-10-30 15:49:17 -04:00
MarcEricMartel
851d5f0c0b
Merge pull request #20 from CegepSTH/SQC-18_Mecanique_de_combat
Sqc 18 mecanique de combat
2023-10-30 15:44:41 -04:00
MarcEricMartel
2a4a5e13cc Correction pour pr20 2023-10-30 15:42:02 -04:00
MarcEricMartel
35c2a5be31 pouet pouet 2023-10-30 15:36:43 -04:00
Jonathan Trottier
9b0c4dc594 modif des degats 2023-10-30 14:58:17 -04:00
Jonathan Trottier
602bb84428 fonctionnel 2023-10-30 14:56:04 -04:00
Jonathan Trottier
4df7cfbd5d Merge branch 'master' into SQC-18_Mecanique_de_combat 2023-10-30 14:37:58 -04:00
Jonathan Trottier
6e75bec25c degats dans bullet 2023-10-30 14:36:44 -04:00
Frederic Leger
2d52abab07 Merge branch 'master' into SQC19_Booster 2023-10-30 14:33:41 -04:00
Frederic Leger
559a8efc19 ajout texture 2023-10-30 14:32:20 -04:00
Claudel-D-Roy
a82f994d49 Merge branch 'SQC19_Booster' of https://github.com/CegepSTH/SQCSim2023 into SQC19_Booster 2023-10-30 14:19:57 -04:00
Claudel-D-Roy
5f3b5b3777 BoosterVert 2023-10-30 14:19:55 -04:00
Frederic Leger
b67d7c647f Merge branch 'master' into SQC19_Booster 2023-10-30 14:09:39 -04:00
Frederic Leger
bbfc98ff12
Merge pull request #19 from CegepSTH/SQC-15_paquets
Sqc 15 paquets
2023-10-30 14:08:48 -04:00
Frederic Leger
9fa4f2829b add boostinfo 2023-10-30 14:03:10 -04:00
MarcEricMartel
3249d68e60 Correction pour l'entrée de données 2023-10-30 13:24:46 -04:00
Jonathan Trottier
ada9330588 Merge branch 'master' into SQC-18_Mecanique_de_combat 2023-10-30 12:38:42 -04:00
MarcEricMartel
3da8be6d52 Gestion pour que ça marche partout 2023-10-30 11:11:13 -04:00
MarcEricMartel
a95dd02896 Cleanup ioctl 2023-10-30 11:07:26 -04:00
MarcEricMartel
6ce7e62e05 pour être sûr 2023-10-29 16:45:57 -04:00
MarcEricMartel
e2dbf52b17 a tester sur Linux (rien change sur windows) 2023-10-29 16:43:09 -04:00
mduval76
eed8f5f04a Push menu solo ou multi. 2023-10-29 15:39:29 -04:00
MarcEricMartel
53ed811936 Va falloir checker si Linux va être content ou pas. 2023-10-29 15:24:03 -04:00
MarcEricMartel
15b4dfefc0 That'll be good 'nough for now. 2023-10-29 15:20:19 -04:00
MarcEricMartel
b50a2f44e2 We are the wooooorld, we are the childreeen 2023-10-29 15:07:01 -04:00
MarcEricMartel
4f64be7e0a Feeeeeed the woooooooooorld 2023-10-29 14:59:29 -04:00
MarcEricMartel
b54f8c31e5 windoes 2023-10-29 14:54:36 -04:00
MarcEricMartel
0b07d46dba Merge branch 'master' into SQC-15_paquets 2023-10-28 14:44:43 -04:00
MarcEricMartel
c33e6f865c I believe in a thing called SOCK_NONBLOCK 2023-10-28 14:41:23 -04:00
03be36ecda J'ai pu de messages de warning quand je build le client 2023-10-28 14:16:39 -04:00
aab3301234 Client Linux qui re-marche 2023-10-28 14:11:01 -04:00
MarcEricMartel
d0c39e49b0 Update netprotocol.cpp 2023-10-28 12:59:19 -04:00
MarcEricMartel
10fcfed05a but I just had to laugh 2023-10-28 12:13:45 -04:00
MarcEricMartel
a69e716105 And though the news was rather sad 2023-10-28 12:06:01 -04:00
MarcEricMartel
3f8d860b93 About a lucky man who made the grade 2023-10-28 12:03:22 -04:00
MarcEricMartel
42d612ad33 I read the news today, oh boy. 2023-10-28 11:18:01 -04:00
MarcEricMartel
c23d1b2120 Surprise. 2023-10-27 16:20:05 -04:00
MarcEricMartel
76a7d0218d Who knows?! 2023-10-27 15:47:34 -04:00
MarcEricMartel
e2e66f3b6c à tester 2023-10-27 15:44:33 -04:00
MarcEricMartel
f0bf7d94ce pas trop loin 2023-10-27 15:19:44 -04:00
MarcEricMartel
49c9576757 Ser/deser Sync 2023-10-27 15:07:38 -04:00
Claudel-D-Roy
e2fa4fea7c Merge branch 'SQC_17_HUD' 2023-10-27 14:53:45 -04:00
MarcEricMartel
61629b3c8e RemotePlayer 2023-10-27 14:37:53 -04:00
MarcEricMartel
8970bc33a1 Répârâge 2023-10-27 14:08:06 -04:00
MarcEricMartel
c1faaca417 Merge branch 'sqc-14_classe_remoteplayer' into SQC-15_paquets 2023-10-27 13:59:26 -04:00
Claudel-D-Roy
889884490b push avant merge 2023-10-27 13:56:48 -04:00
MarcEricMartel
bd817f9f7d Merge branch 'sqc-14_classe_remoteplayer' of https://github.com/CegepSTH/SQCSim2023 into sqc-14_classe_remoteplayer 2023-10-27 13:55:25 -04:00
MarcEricMartel
57d60e02a7 getId() 2023-10-27 13:55:15 -04:00
Claudel-D-Roy
ae201846b1 push de correction 2023-10-27 13:54:37 -04:00
MarcEricMartel
1c7523558b Changé de port 2023-10-27 13:39:18 -04:00
mduval76
fc4a22e844 Push sans le menu solo/multi. 2023-10-27 13:27:15 -04:00
MarcEricMartel
f7b7a7f14d Changements C++20 et retour audio 2023-10-27 13:27:00 -04:00
MarcEricMartel
102153a093
Merge pull request #18 from CegepSTH/L-CSplash
Créé branche_L_C
2023-10-27 12:38:40 -04:00
da594fa3a2 correction client 2023-10-27 12:23:45 -04:00
6a8a505167 Yeehaw. 2023-10-27 12:02:29 -04:00
0dded0bc9b try câtch 2023-10-27 10:40:53 -04:00
9ef44a3993 Ev'ryday I'm bufferin'. 2023-10-27 09:51:40 -04:00
0bc7f29492 Gros refactoring sale. 2023-10-27 09:28:34 -04:00
60cc69a407 Erratum VI: The Final Chapter 2023-10-26 17:57:42 -04:00
05f9658f55 erratum V? 2023-10-26 17:18:30 -04:00
2f2b49054f erratum IV 2023-10-26 11:17:13 -04:00
397cf7f00d erratum III 2023-10-26 10:55:36 -04:00
8e95899192 erratum II 2023-10-26 10:47:17 -04:00
8870550512 erratum 2023-10-26 10:42:24 -04:00
f5a1906877 Cleanup de srv 2023-10-26 10:39:08 -04:00
MarcEricMartel
9b4defba2a à tester 2023-10-25 12:16:14 -04:00
MarcEricMartel
dd2396e5e4 ajout LoginInfo dans le parseur de paquet. 2023-10-25 10:00:54 -04:00
mduval76
c7271f6217 Push skybox ciel éclairé 2023-10-25 02:06:29 -04:00
mduval76
8ebe7b95fc Push menu solo/multi avec titre et quads contenant choix. Manque persistence du menu en 2D et nom des choix dans les quads. 2023-10-25 01:01:25 -04:00
MarcEricMartel
4964bc5394 ajouts dans netprot 2023-10-24 10:43:30 -04:00
MarcEricMartel
cf6e58cd95 erratas dans la sérialisation 2023-10-24 09:17:21 -04:00
MarcEricMartel
ffeb95d953 direction fonctionnelle! 2023-10-24 07:32:16 -04:00
Rynort
85f4f82660 avancement menu pause 2023-10-23 17:51:29 -04:00
MarcEricMartel
2c3abff96f et c'est un début! 2023-10-23 17:49:40 -04:00
Claudel-D-Roy
5e29c9be54 push menu image 2023-10-23 17:11:13 -04:00
Louis-Charles Gaumond
f8680a318a Changement dans le splachscreen 2023-10-23 16:57:19 -04:00
MarcEricMartel
fc4aa20005 Update server.cpp 2023-10-23 16:54:09 -04:00
MarcEricMartel
ecfe5b893b connection? 2023-10-23 16:44:34 -04:00
MarcEricMartel
eea6a30aa5 aaaaaaa 2023-10-23 16:23:57 -04:00
MarcEricMartel
9f615db929 erratum 2023-10-23 16:23:27 -04:00
MarcEricMartel
498fb7baf7 lol 2023-10-23 16:21:15 -04:00
MarcEricMartel
49240635b6 sendpack qui fonctionne avec le client 2023-10-23 16:20:52 -04:00
mduval76
df5b7960b2 Push placement text notification queue 2023-10-23 16:11:35 -04:00
Louis-Charles Gaumond
f4d4f1eca0 Créé branche 2023-10-23 16:10:21 -04:00
Jonathan Trottier
b943a268ae barre de vie 2023-10-23 15:43:55 -04:00
MarcEricMartel
590220bc92 ajout d'adresse de serveur 2023-10-23 15:41:07 -04:00
Claudel-D-Roy
67a49a4cad push de remote player 2023-10-23 15:35:31 -04:00
Frederic Leger
dd851a17e1
Merge pull request #17 from CegepSTH/master
update branche
2023-10-23 12:50:03 -04:00
MarcEricMartel
0e7b8973e7 setup louche en console 2023-10-18 09:59:34 -04:00
MarcEricMartel
2cb7d4c776 Début 2023-10-18 09:33:56 -04:00
MarcEricMartel
793da52871
Merge pull request #14 from CegepSTH/sqc-20_audiobullet
whoooosh!
2023-10-16 17:44:56 -04:00
MarcEricMartel
18a5d98c57
Merge branch 'master' into sqc-20_audiobullet 2023-10-16 17:43:32 -04:00
MarcEricMartel
81240c6f70
Merge pull request #11 from CegepSTH/linux
Serveur Linux
2023-10-16 17:38:59 -04:00
MarcEricMartel
f1ddd67655
Merge pull request #16 from CegepSTH/SQC-09
Sqc 09
2023-10-16 17:38:40 -04:00
MarcEricMartel
a054a7bff1 On l'a eu! 2023-10-16 17:36:04 -04:00
MarcEricMartel
b712c950c6 Merge branch 'master' into SQC-09 2023-10-16 16:35:26 -04:00
MarcEricMartel
9cbf20ba21 whoooosh! 2023-10-16 12:02:37 -04:00
Rynort
3f774d7c2e Réparation de la vitesse de la souris 2023-10-16 03:06:00 -04:00
mduval76
db0a39f64a Remaniement du HUD. TOUT est scalable aux dimensions du game window. % de vie ajouté. Font size multipliable. 2023-10-15 23:36:26 -04:00
Claudel-D-Roy
d7e55c8446 Début de la classe remoteplayer.cpp, à vérifier 2023-10-15 16:23:43 -04:00
MarcEricMartel
f2095f6e5b Merge branch 'linux' of https://github.com/CegepSTH/SQCSim2023 into linux 2023-10-07 11:43:55 -04:00
MarcEricMartel
183c5f186a Architecture générale 2023-10-03 12:43:54 -04:00
MarcEricMartel
c85f7df15e Merge branch 'master' into linux 2023-10-03 11:34:02 -04:00
Rynort
6668127f15 SQC-06 et une partie du SQC-09 2023-10-02 17:09:03 -04:00
MarcEricMartel
54c25e6f78
Merge pull request #13 from CegepSTH/thehell_affichageMESS
SQC-8_Messagerie
2023-10-02 16:37:02 -04:00
Jonathan Trottier
bf164af23b changement de la grosseur du texte
les touches K et L pour faire afficher du texte
2023-10-02 16:27:41 -04:00
Claudel-D-Roy
0d948e3a28 Merge branch 'master' of https://github.com/CegepSTH/SQCSim2023 2023-10-02 16:27:26 -04:00
Claudel-D-Roy
b97890fff3 BrasDuJoueur 2023-10-02 16:27:21 -04:00
MarcEricMartel
432b8545a7 Merge branch 'master' into affichage_des_messages 2023-10-02 16:14:22 -04:00
Jonathan Trottier
54e2f32aba comments 2023-10-02 15:58:08 -04:00
Jonathan Trottier
90fdc8ed1b deux méthodes pour afficher message systeme et notification de kill 2023-10-02 15:55:45 -04:00
Frederic Leger
47906776c8
Merge pull request #10 from CegepSTH/sqc_51-fin
Corrections fichiers pour avoir la version x86 du client fonctionnelle
2023-10-02 15:52:28 -04:00
Claudel-D-Roy
fa9f0a3a8a Merge branch 'master' of https://github.com/CegepSTH/SQCSim2023 2023-10-01 13:59:07 -04:00
Claudel-D-Roy
43f3ce1428 Bouton pour menu 2023-10-01 13:58:59 -04:00
MarcEricMartel
8b3baa9063 Corrections fichiers pour avoir la version x86 fonctionnelle 2023-09-30 18:33:23 -04:00
884 changed files with 126896 additions and 1196 deletions

2
.gitignore vendored
View File

@ -378,3 +378,5 @@ FodyWeavers.xsd
/SQCSim2021/cmake/*
!/SQCSim2021/cmake/CMakeLists.txt
/SQCSim2021/SQCSim-client
SQCSim2021/SQCSim2021.vcxproj.filters
SQCSim2021/SQCSim2021.vcxproj

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

View File

@ -76,6 +76,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -90,6 +91,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -104,6 +106,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -118,7 +121,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp17</LanguageStandard>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -128,9 +131,11 @@
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="booster.h" />
<ClInclude Include="array2d.h" />
<ClInclude Include="array3d.h" />
<ClInclude Include="blockinfo.h" />
<ClInclude Include="boostinfo.h" />
<ClInclude Include="bullet.h" />
<ClInclude Include="chunk.h" />
<ClInclude Include="define.h" />
@ -143,7 +148,9 @@
<ClInclude Include="world.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="booster.cpp" />
<ClCompile Include="blockinfo.cpp" />
<ClCompile Include="boostinfo.cpp" />
<ClCompile Include="bullet.cpp" />
<ClCompile Include="chunk.cpp" />
<ClCompile Include="netprotocol.cpp" />

View File

@ -54,6 +54,12 @@
<ClInclude Include="transformation.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="booster.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="boostinfo.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="world.cpp">
@ -80,5 +86,11 @@
<ClCompile Include="transformation.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="booster.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="boostinfo.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
</ItemGroup>
</Project>

39
SQCSim-common/booster.cpp Normal file
View File

@ -0,0 +1,39 @@
#include "booster.h"
Booster::Booster()
{
}
Booster::Booster(Vector3f tpos, BOOST_TYPE ttype, uint64_t id): m_id(id), pos(tpos), type(ttype){}
Booster::~Booster()
{
}
Vector3f Booster::GetPosition()
{
return pos;
}
BOOST_TYPE Booster::GetType()
{
return type;
}
uint64_t Booster::GetId() const
{
return m_id;
}
bool Booster::GetAvailability()
{
return available;
}
void Booster::SetAvailability(bool value)
{
available = value;
modified = true;
}

23
SQCSim-common/booster.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef BOOSTER_H__
#define BOOSTER_H__
#include "define.h"
#include "vector3.h"
class Booster {
public:
Booster();
Booster(Vector3f tpos, BOOST_TYPE ttype, uint64_t id);
~Booster();
Vector3f GetPosition();
BOOST_TYPE GetType();
uint64_t GetId() const;
bool GetAvailability();
void SetAvailability(bool value);
bool modified = true;
private:
Vector3f pos;
BOOST_TYPE type;
uint64_t m_id;
bool available = true;
};
#endif

View File

@ -0,0 +1,32 @@
#include "boostinfo.h"
#include <iostream>
BoostInfo::BoostInfo(BoostType type, const std::string& name, float u, float v, float s, int dur) : m_type(type), m_name(name), m_u(u), m_v(v), m_s(s), m_durability(dur)
{
}
BoostInfo::~BoostInfo()
{
}
BoostType BoostInfo::GetType() const
{
return m_type;
}
void BoostInfo::GetTexture(float& u, float& v, float& s)
{
u = m_u;
v = m_v;
s = m_s;
}
void BoostInfo::Show() const
{
std::cout << "Type: " << m_type << std::endl;
std::cout << "Nom: " << m_name << std::endl;
std::cout << "Durabilite: " << m_durability << std::endl;
std::cout << "Coordonnees Texture: " << m_u << ", " << m_v << ", " << m_s << std::endl;
}

29
SQCSim-common/boostinfo.h Normal file
View File

@ -0,0 +1,29 @@
#ifndef BOOSTINFO_H__
#define BOOSTINFO_H__
#include <string>
#include "define.h"
class BoostInfo
{
public:
BoostInfo(BoostType type, const std::string& name, float u, float v, float s, int dur);
~BoostInfo();
BoostType GetType() const;
void GetTexture(float& u, float& v, float& s);
void Show() const;
private:
BoostType m_type;
float m_u;
float m_v;
float m_s;
std::string m_name;
int m_durability;
};
#endif // BOOSTINFO_H__

View File

@ -3,18 +3,63 @@
Bullet::Bullet(Vector3f pos, Vector3f dir) : m_startpos(pos), m_currentpos(pos), m_velocity(dir) {}
Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t tid): m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_tid(tid) {}
Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t shooter_id) : m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_shooter_id(shooter_id) {}
Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t shooter_id, bool canhurt): m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_shooter_id(shooter_id), m_canhurt(canhurt) {}
Bullet::~Bullet() {}
bool Bullet::Update(World* world, float elapsedtime) {
for (int x = 0; x < 1000; ++x) {
bool Bullet::Update(World* world, float elapsedtime, int perframe, std::unordered_map<uint64_t, Player*> mapPlayer, netprot::ChunkMod** chunkmod) {
int max = 100 / perframe;
Player* shooter = nullptr;
float damage = 0.098f;
if (mapPlayer.count(m_shooter_id)) {
shooter = mapPlayer.at(m_shooter_id);
damage = shooter->boostdamage ? 0.123f : 0.098f;
}
for (int x = 0; x < max; ++x) {
m_currentpos += m_velocity * elapsedtime;
for (auto& [key, player] : mapPlayer) {
if (key == m_shooter_id)
continue;
bool hit = false;
if ((m_currentpos - player->GetPosition()).Length() < 1.5f) {
hit = true;
}
else if ((m_currentpos - player->GetPOV()).Length() < .7f) {
damage *= 2; // HEADSHOT!
hit = true;
}
if (hit && !player->AmIDead()) {
if (m_canhurt && !player->boostinvincible)
player->InflictDamage(damage);
player->m_hit = true;
if (player->AmIDead())
player->Killer = m_shooter_id;
return true;
}
}
if (!world->ChunkAt(m_currentpos))
return true;
else if (world->BlockAt(m_currentpos) != BTYPE_AIR) {
if (m_canhurt) {
if (chunkmod) {
using namespace netprot;
*chunkmod = new ChunkMod();
(*chunkmod)->old_b_type = world->BlockAt(m_currentpos);
(*chunkmod)->b_type = BTYPE_AIR;
(*chunkmod)->pos = m_currentpos;
}
world->ChangeBlockAtPosition(BTYPE_AIR, m_currentpos);
}
return true;
}
else if ((m_currentpos - m_startpos).Length() > VIEW_DISTANCE) return true;
@ -30,10 +75,14 @@ void Bullet::Transpose(int& x, int& z) {
m_startpos.z -= z * CHUNK_SIZE_Z;
}
Vector3f Bullet::getPos() {
Vector3f Bullet::getPos() const {
return m_currentpos;
}
uint64_t Bullet::getTeamID(){
return m_tid;
Vector3f Bullet::getVel() const {
return m_velocity;
}
//uint64_t Bullet::getTeamID(){
// return m_tid;
//}

View File

@ -1,27 +1,37 @@
#ifndef BULLET_H__
#define BULLET_H__
#include <unordered_map>
#include "define.h"
#include "vector3.h"
#include "player.h"
#include "netprotocol.h"
class World;
class Player;
class Bullet {
public:
Bullet(Vector3f pos, Vector3f dir);
Bullet(Vector3f pos, Vector3f dir, uint64_t tid);
Bullet(Vector3f pos, Vector3f dir, uint64_t tid, bool canhurt);
~Bullet();
bool Update(World* world, float elapsedtime);
bool Update(World* world, float elapsedtime, int perframe, std::unordered_map<uint64_t, Player*> m_mapPlayer, netprot::ChunkMod** chunkmod);
void Transpose(int& x, int& z);
Vector3f getPos();
uint64_t getTeamID();
Vector3f getPos() const;
Vector3f getVel() const;
//uint64_t getTeamID();
private:
Vector3f m_startpos,
m_currentpos,
m_velocity;
uint64_t m_tid = 0;
uint64_t m_shooter_id = 0;
bool m_canhurt = true;
};
#endif // BULLET_H__

View File

@ -1,83 +1,254 @@
#include "chunk.h"
#include "world.h"
#include <random>
Chunk::Chunk(unsigned int x, unsigned int y, int64_t seed) : m_posX(x), m_posY(y) {
//std::ostringstream pos; // Vérifie l'existence d'un fichier .chunk avec sa position.
//std::ostringstream pos; // V<>rifie l'existence d'un fichier .chunk avec sa position.
//pos << CHUNK_PATH << x << '_' << y << ".chunk";
//std::ifstream input(pos.str(), std::fstream::binary);
//if (input.fail()) {
OpenSimplexNoise::Noise simplex = OpenSimplexNoise::Noise(seed);
int ratio = 0;
ratio = x * y % 7;
m_blocks.Reset(BTYPE_AIR);
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // Montagnes
#pragma region Montagnes et Grass des montagnes
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix)
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
float xnoiz, ynoiz;
xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 4096.;
ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 4096.;
xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 4796.;
ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 4796.;
double height = 0;
for (int x = 0; x < 39; ++x) {
height += simplex.eval(xnoiz, ynoiz);
height *= .79;
xnoiz *= 1.139;
ynoiz *= 1.139;
xnoiz *= 1.1305;
ynoiz *= 1.1305;
}
height = height * 2000. * simplex.eval((double)(ix + x * CHUNK_SIZE_X) / 512., (double)(iz + y * CHUNK_SIZE_Z) / 512.);
height /= (CHUNK_SIZE_Y / 1.9);
height += 15.;
for (int iy = 0; iy <= (int)height % CHUNK_SIZE_Y; ++iy)
SetBlock(ix, iy, iz, BTYPE_METAL, nullptr);
}
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // Collines
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
float xnoiz, ynoiz;
xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 512.;
ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 512.;
float height = simplex.eval(xnoiz, ynoiz) * 50.f;// +1.f;
for (int iy = 0; iy <= (int)height % CHUNK_SIZE_Y; ++iy) {
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
if (iy < 20)
{
//std::cout << "" << ynoiz << std::endl;
SetBlock(ix, iy, iz, BTYPE_GRASS, nullptr);
}
else if (iy == 20 || iy == 21) {
double fractionalPart = ynoiz - static_cast<int>(ynoiz);
if (iy == 20) {
if (fractionalPart < 0.3) {
SetBlock(ix, iy, iz, BTYPE_GRASS, nullptr);
}
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // "Lacs"
else {
SetBlock(ix, iy, iz, BTYPE_METAL, nullptr);
}
}
else if (iy == 21) {
if (fractionalPart < 0.6) {
SetBlock(ix, iy, iz, BTYPE_GRASS, nullptr);
}
else {
SetBlock(ix, iy, iz, BTYPE_METAL, nullptr);
}
}
}
else
{
SetBlock(ix, iy, iz, BTYPE_METAL, nullptr);
}
}
}
#pragma endregion
#pragma region Lacs
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix)
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
for (int iy = 0; iy < 13; ++iy) {
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
if (iy < 5 && GetBlock(ix, iy, iz) == BTYPE_AIR) {
SetBlock(ix, iy, iz, BTYPE_ICE, nullptr);
}
else if (iy >= 5 && GetBlock(ix, iy, iz) == BTYPE_AIR) {
SetBlock(ix, iy, iz, BTYPE_ICE, nullptr);
}
}
//for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // "Arbres"
}
#pragma endregion
//int rnd = rand() % 15;
if (ratio == 1)
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // structure
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
for (int iy = 0; iy < 14; ++iy) {
if (ix == 3)
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
Structure(ix, iy, iz, 2);
}
}
if (ratio == 3)
for (int ix = 0; ix < CHUNK_SIZE_Z; ++ix) // structure
for (int iz = 0; iz < CHUNK_SIZE_X; ++iz) {
for (int iy = 0; iy < 14; ++iy) {
if (iz == 4)
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
Structure(ix, iy, iz, 1);
}
}
if (ratio == 5)
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // structure
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
for (int iy = 0; iy < 14; ++iy) {
if (ix == 3)
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
Structure(ix, iy, iz, 2);
}
}
#pragma region Arbre
double valeurRnd = 0;
int treeheight = 10;
int lastTreeX = -1;
int lastTreeZ = -1;
int minDistanceBetweenTrees = 10; // Définir la distance minimale entre les arbres
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) {
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
if (GetBlock(ix, 0, iz) != BTYPE_ICE) {
float xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 4796.;
float ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 4796.;
double height = 0;
for (int i = 0; i < 39; ++i) {
height += simplex.eval(xnoiz, ynoiz);
height *= .79;
xnoiz *= 1.1305;
ynoiz *= 1.1305;
}
height = height * 2000. * simplex.eval((double)(ix + x * CHUNK_SIZE_X) / 512., (double)(iz + y * CHUNK_SIZE_Z) / 512.);
height /= (CHUNK_SIZE_Y / 1.9);
height += 15.;
if (GetBlock(ix, (int)height, iz) == BTYPE_GRASS || (GetBlock(ix, (int)height, iz) == BTYPE_METAL)) {
valeurRnd = simplex.eval(xnoiz, ynoiz);
int distanceThreshold = 20;
// Vérifie si l'emplacement n'est pas à l'intérieur des lacs
bool isInsideLake = false;
for (int iy = 0; iy < 13; ++iy) {
if (GetBlock(ix, iy, iz) == BTYPE_ICE) {
isInsideLake = true;
break;
}
}
if (!isInsideLake && ((valeurRnd > -0.4 && valeurRnd < -0.38) || (valeurRnd > -0.35 && valeurRnd < -0.31)
|| (valeurRnd > 0.3 && valeurRnd < 0.32) || (valeurRnd > 0.37 && valeurRnd < 0.39))
) {
if (lastTreeX == -1 || abs(ix - lastTreeX) > minDistanceBetweenTrees || abs(iz - lastTreeZ) > minDistanceBetweenTrees) {
if (valeurRnd < 0.1)
treeheight = 10;
else {
treeheight = valeurRnd * 20;
if (treeheight < 5)
treeheight = 5;
}
PlaceTree(ix, height, iz, treeheight);
lastTreeX = ix;
lastTreeZ = iz;
}
}
}
}
}
}
#pragma endregion
//else {
// input.seekg(0, std::ios_base::end);
// int size = input.tellg();
// input.seekg(0, std::ios_base::beg);
// char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
// input.read(data, size);
// input.close();
// for (int ix = 0; ix < CHUNK_SIZE_X; ++ix)
// for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz)
// for (int iy = 0; iy < CHUNK_SIZE_Y; ++iy)
// m_blocks.Set(ix, iy, iz, data[ix + (iz * CHUNK_SIZE_X) + (iy * CHUNK_SIZE_Z * CHUNK_SIZE_X)]);
//}*/
//for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // Collines
// for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
// float xnoiz, ynoiz;
// xnoiz = (double)(iz * CHUNK_SIZE_Y + x * CHUNK_SIZE_X) / 256.;
// ynoiz = (double)(ix * CHUNK_SIZE_Y + y * CHUNK_SIZE_Z) / 256.;
// bool tree = (int)(abs(simplex.eval(xnoiz, ynoiz)) * 17933.f) % CHUNK_SIZE_Y > 126 ? true : false;
// for (int iy = 0; iy < CHUNK_SIZE_Y - 10; ++iy)
// if (GetBlock(ix, iy, iz) == BTYPE_AIR)
// if (GetBlock(ix, iy - 1, iz) == BTYPE_GRASS)
// if (tree) {
// for (int i = 0; i < (int)(abs(simplex.eval(xnoiz, ynoiz) * 4)) % 42 + 1; ++i)
// SetBlock(ix, iy + i, iz, BTYPE_DIRT, nullptr);
// break;
// xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 512.;
// ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 512.;
// float height = simplex.eval(xnoiz, ynoiz) * 50.f;// +1.f;
// for (int iy = 0; iy <= (int)height % CHUNK_SIZE_Y; ++iy) {
// if (iy < 10 && GetBlock(ix, iy, iz) == BTYPE_AIR) {
// SetBlock(ix, iy, iz, BTYPE_METAL, nullptr); // Collines
// }
// else if (iy >= 10 && GetBlock(ix, iy, iz) == BTYPE_AIR) {
// SetBlock(ix, iy, iz, BTYPE_GRASS, nullptr); // Grass des collines
// }
// }
// }
/* }
else {
input.seekg(0, std::ios_base::end);
int size = input.tellg();
input.seekg(0, std::ios_base::beg);
char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
input.read(data, size);
input.close();
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix)
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz)
for (int iy = 0; iy < CHUNK_SIZE_Y; ++iy)
m_blocks.Set(ix, iy, iz, data[ix + (iz * CHUNK_SIZE_X) + (iy * CHUNK_SIZE_Z * CHUNK_SIZE_X)]);
}*/
}
void Chunk::PlaceTree(int x, int y, int z, int height) {
// Vérifie si les coordonnées x, y, z sont dans les limites du chunk
if (x < 0 || x >= CHUNK_SIZE_X || y < 0 || y >= CHUNK_SIZE_Y || z < 0 || z >= CHUNK_SIZE_Z) {
// Coordonnées hors limites du chunk, sortie anticipée pour éviter tout accès non valide
return;
}
// Place la tige de l'arbre
for (int iy = 0; iy < height + 1; ++iy) {
if (y + iy < CHUNK_SIZE_Y) { // Vérifie si la hauteur est à l'intérieur des limites du chunk
SetBlock(x, y + iy, z, BTYPE_DIRT, nullptr);
}
}
// Place les feuilles de l'arbre
int foliageHeight = height / 2;
for (int dy = 0; dy < foliageHeight; ++dy) {
for (int dx = -4; dx <= 4; ++dx) {
for (int dz = -4; dz <= 4; ++dz) {
// Vérifie que les coordonnées se trouvent à l'intérieur des limites du chunk
if (x + dx >= 0 && x + dx < CHUNK_SIZE_X && y + height + dy >= 0 && y + height + dy < CHUNK_SIZE_Y &&
z + dz >= 0 && z + dz < CHUNK_SIZE_Z) {
// Vérifie si le bloc est à une distance acceptable du centre des feuilles pour les placer
double distanceSquared = dx * dx + dy * dy + dz * dz;
if (distanceSquared < 20) {
SetBlock(x + dx, y + height + dy, z + dz, BTYPE_GREENGRASS, nullptr);
}
}
}
}
}
}
Chunk::~Chunk() {
/*if (m_isModified) {
char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
@ -104,7 +275,7 @@ void Chunk::RemoveBlock(int x, int y, int z, World* world) {
void Chunk::SetBlock(int x, int y, int z, BlockType type, World* world) {
m_blocks.Set(x, y, z, type);
if (world) CheckNeighbors(x, z, world); // Si nullptr, ne pas vérifier les chunks voisines.
if (world) CheckNeighbors(x, z, world); // Si nullptr, ne pas v<EFBFBD>rifier les chunks voisines.
m_isDirty = true;
}
@ -132,6 +303,10 @@ void Chunk::CheckNeighbors(unsigned int x, unsigned int z, World* world) {
void Chunk::GetPosition(unsigned int& x, unsigned int& y) const { x = m_posX; y = m_posY; }
bool Chunk::IsDirty() const { return m_isDirty; }
void Chunk::MakeDirty() { m_isDirty = true; }
@ -140,3 +315,11 @@ void Chunk::MakeClean() { m_isDirty = false; }
void Chunk::MakeModified() { m_isModified = true; }
void Chunk::Structure(int x, int y, int z,int height)
{
for (int i = 0; i < height; i++)
{
SetBlock(x, i + y, z, BTYPE_GRASS, nullptr);
}
}

View File

@ -27,7 +27,9 @@ class Chunk {
BlockType GetBlock(int x, int y, int z);
void CheckNeighbors(unsigned int x, unsigned int z, World* world);
void GetPosition(unsigned int& x, unsigned int& y) const;
void PlaceTree(int x, int y, int z, int height);
void Structure(int x, int y, int z, int height);
bool IsDirty() const;
void MakeDirty();
void MakeClean();

View File

@ -4,12 +4,14 @@
#include <iostream>
#include <chrono>
#define SRV_PORT 1025
#define CLI_PORT 1026
#define SRV_PORT 10000
#define CLI_PORT 10001
#define CHUNK_SIZE_X 4
#define BUFFER_LENGTH 1500
#define CHUNK_SIZE_X 6
#define CHUNK_SIZE_Y 64
#define CHUNK_SIZE_Z 4
#define CHUNK_SIZE_Z 6
#define MAX_SELECTION_DISTANCE 5
#define SEED 0
#define COUNTDOWN 300
@ -22,26 +24,50 @@
#define FRAMES_DELETE_CHUNKS 1
#define THREADS_GENERATE_CHUNKS 8
#define THREADS_UPDATE_CHUNKS 3
#define THREADS_UPDATE_CHUNKS 6
#define THREADS_DELETE_CHUNKS 3
#define VIEW_DISTANCE 512 // Si les chunks arrêtent de s'afficher pendant une game et qu'il y a un access violation quand tu quitte, il faut augmenter ce chiffre.
#define VIEW_DISTANCE 512 // Si les chunks arr<EFBFBD>tent de s'afficher pendant une game et qu'il y a un access violation quand tu quitte, il faut augmenter ce chiffre.
#define TEXTURE_SIZE 512
#define MAX_BULLETS 512
#define NB_BOOST 2
#define TIME_SPEED_BOOST 10 //secondes
#define TIME_DAMAGE_BOOST 10 //secondes
#define TIME_INVINCIBLE_BOOST 4 //secondes
#define STRENGTH_SPEED_BOOST 1000 //Pourcentage
#define BULLET_TIME .2 //secondes
#define SYNC_ACC 600 // ms
#define CMOD_ACC 1000 // ms
typedef uint8_t BlockType;
enum BLOCK_TYPE { BTYPE_AIR, BTYPE_DIRT, BTYPE_GRASS, BTYPE_METAL, BTYPE_ICE, BTYPE_LAST };
enum BLOCK_TYPE { BTYPE_AIR, BTYPE_DIRT, BTYPE_GRASS, BTYPE_METAL, BTYPE_ICE, BTYPE_GREENGRASS, BTYPE_LAST };
typedef uint8_t BoostType;
enum BOOST_TYPE { BTYPE_SPEED, BTYPE_HEAL, BTYPE_DAMAGE, BTYPE_INVINCIBLE, BTYPE_BOOST_LAST };
//anim
enum ANIM_TYPE { STILL = 0, SHOOTING = 8, JUMPING = 16, JUMPINGSHOOTING = 24, DEAD = 32, TYPE_LAST = 40};
enum ANIM_POS {FRONT, QUARTER_FRONT_LEFT, QUATER_FRONT_RIGHT, PROFIL_LEFT, PROFIL_RIGHT, QUARTER_BACK_LEFT, QUARTER_BACK_RIGHT, BACK , POS_LAST};
typedef uint64_t Timestamp;
#ifdef _WIN32
#pragma comment(lib,"wsock32.lib") // Pour pouvoir faire fonctionner le linker sans le vcxproject
#pragma comment(lib,"ws2_32.lib")
#include <ws2tcpip.h>
#include <Windows.h>
#include <cstdio>
#include <ctime>
#define poll WSAPoll
#define flag_t u_long
#define addrlen_t int
#define ioctl ioctlsocket
#define SOCK_NONBLOCK FIONBIO
#define strcpy strcpy_s
#define popen _popen
#define pclose _pclose
@ -51,10 +77,14 @@ typedef uint64_t Timestamp;
#include <time.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <cstring>
#include <poll.h>
#define flag_t unsigned int
#define addrlen_t unsigned int
#define SOCKET int
#define INVALID_SOCKET -1
#define closesocket close

File diff suppressed because it is too large Load Diff

View File

@ -1,41 +1,71 @@
#ifndef NETPROTOCOL_H__
#define NETPROTOCOL_H__
#include "define.h"
#include <string>
#include "define.h"
#include "vector3.h"
/* Protocole Particulier de Partie à Plusieurs Personnes (PPPPP) */
// Packet: packet[0] = PacketType, packet[1..n-1] = {packet}
/* Protocole Particulier de Partie a Plusieurs Personnes (PPPPP) */
namespace netprot {
typedef uint8_t PacketType;
enum PACKET_TYPE {
enum class PACKET_TYPE: uint8_t {
ERR, INPUT, OUTPUT, SYNC,
TEAMINF, SELFINF, PLAYINF, LOGINF,
CHUNKMOD, PLAYERMOD, PICKUPMOD,
GAMEINFO, ENDINFO , CHAT, ERRLOG,
LAST_PACK
GAMEINFO, ENDINFO , BULLET,
CHAT, ERRLOG, LAST_PACK
};
/* Structures */
struct Buffer { // Pour pouvoir rendre l'utilisation des buffers plus clean.
char *ptr = new char[BUFFER_LENGTH] { 1 }, *tmp = nullptr;
uint32_t len = BUFFER_LENGTH;
~Buffer() { delete[] ptr; }
void rstLen() { len = BUFFER_LENGTH; }
};
struct Packet { // Pour pouvoir recevoir les paquets du recv() sans avoir à les aiguiller dans la même thread.
void *ptr = nullptr; // Notez que le pointeur doit être supprimé séparément lorsqu'il n'est plus utile.
PACKET_TYPE type = PACKET_TYPE::ERR;
};
/* Constantes */
inline const char Footer[sizeof(uint32_t)] = { '\0', '\r', '\0', '\n' }; // constante de footer qui est ajoutée à chaque paquet envoyé.
/* Sous-structures */
struct Keys {
bool forward,
backward,
left,
right,
jump,
shoot,
block;
bool forward = false,
backward = false,
left = false,
right = false,
jump = false,
shoot = false,
block = false;
};
struct States {
bool jumping,
shooting,
hit,
powerup;
bool jumping = false,
shooting = false,
hit = false,
powerup = false,
dead = false,
still = false,
jumpshot = false,
running = false;
};
struct Boosts {
bool invincible = false,
damage = false,
hp = false;
};
/* Structures de paquets */
struct Input { // cli -> srv UDP ~frame
Timestamp timestamp;
uint64_t sid = 0;
@ -51,50 +81,93 @@ namespace netprot {
States states; // 0bJSH_____ bit-packing de bool.
};
struct Sync { // srv -> cli TCP ~second
struct Sync { // srv -> cli TCP ~second - un premier sync démarre la partie.
Timestamp timestamp;
uint64_t sid = 0;
uint32_t timer = 0;
uint16_t ammo = 0;
uint8_t hp = 0;
Boosts boost;
float hp = 0;
Vector3f position;
Sync() {}
Sync(Sync* sync) : timestamp(sync->timestamp), sid(sync->sid), timer(sync->timer), ammo(sync->ammo), hp(sync->hp), position(sync->position), boost(sync->boost) {}
};
struct TeamInfo { // cli <-> srv TCP once
char name[32];
char *name = new char[32];
uint64_t id = 0;
TeamInfo() {}
TeamInfo(TeamInfo* tem) : id(tem->id) { strcpy(name, 32, tem->name); }
~TeamInfo() { delete[] name; }
};
struct LoginInfo { // cli <-> srv TCP once
char name[32];
char *name = new char[32];
uint64_t sid = 0,
tid = 0;
LoginInfo() {}
LoginInfo(LoginInfo* log): sid(log->sid), tid(log->tid) { strcpy(name, 32, log->name); }
~LoginInfo() { delete[] name; }
};
struct PlayerInfo { // cli <-> srv TCP once
char name[32];
char *name = new char[32];
uint64_t id = 0,
tid = 0;
PlayerInfo() {}
PlayerInfo(PlayerInfo* ply) : id(ply->id), tid(ply->tid) { strcpy(name, 32, ply->name); };
PlayerInfo(int id, int tid, std::string strname) : id(id), tid(tid) { strcpy(name, 32, strname.c_str()); }
~PlayerInfo() { delete[] name; }
};
struct GameInfo { // cli <-> srv TCP event (before game start)/ once
uint64_t seed;
uint32_t countdown;
uint8_t gameType; // TOOD: enum.
uint8_t gameType; // TODD: enum.
GameInfo() {}
GameInfo(GameInfo* gam) : seed(gam->seed), countdown(gam->countdown), gameType(gam->gameType) {}
};
struct PickupMod {
uint64_t id;
Vector3f pos;
Boosts boost;
bool available = true;
PickupMod() {}
PickupMod(PickupMod* pmod) : id(pmod->id), pos(pmod->pos), boost(pmod->boost), available(pmod->available) {}
};
struct Chat { // cli <-> srv TCP event
uint64_t src_id = 0,
dest_id = 0,
dest_team_id = 0;
char mess[140]; // Good 'nough for twitr, good 'nough for me.
char *mess = new char[140]; // Good 'nough for twitr, good 'nough for me.
Chat() {}
Chat(Chat* cha) : src_id(cha->src_id), dest_id(cha->dest_id), dest_team_id(cha->dest_team_id) { strcpy(mess, 140, cha->mess); }
~Chat() { delete[] mess; }
};
struct ChunkMod {
Vector3f pos;
BlockType b_type, old_b_type;
};
struct BulletAdd {
Timestamp tstamp;
Vector3f pos, dir;
uint64_t id;
};
struct ErrorLog { // srv -> cli TCP event
char mess[140];
bool is_fatal;
char *mess = new char[140];
bool is_fatal = false;
ErrorLog() {};
ErrorLog(ErrorLog* err) : is_fatal(err->is_fatal) { strcpy(mess, 140, err->mess); }
~ErrorLog() { delete[] mess; }
};
/* Fonctions */
void Serialize(Input* in, char* buf[], uint32_t* buflen); // cli
void Serialize(Output* out, char* buf[], uint32_t* buflen); // srv
void Serialize(Sync* sync, char* buf[], uint32_t* buflen); // srv
@ -103,18 +176,86 @@ namespace netprot {
void Serialize(PlayerInfo* pinfo, char* buf[], uint32_t* buflen); // srv
void Serialize(GameInfo* ginfo, char* buf[], uint32_t* buflen); // cli/srv
void Serialize(Chat* chat, char* buf[], uint32_t* buflen); // cli/srv
void Serialize(ChunkMod* chmod, char* buf[], uint32_t* buflen); // srv
void Serialize(PickupMod* chmod, char* buf[], uint32_t* buflen); // srv
void Serialize(BulletAdd* bull, char* buf[], uint32_t* buflen); // srv
void Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen); // srv
bool Deserialize(Input* in, char* buf, const uint32_t buflen); // srv
bool Deserialize(Output* out, char* buf, const uint32_t buflen); // cli
bool Deserialize(Sync* sync, char* buf, const uint32_t buflen); // cli
bool Deserialize(TeamInfo* tinfo, char* buf, const uint32_t buflen); // cli/srv
bool Deserialize(LoginInfo* linfo, char* buf, const uint32_t buflen); // cli/srv
bool Deserialize(PlayerInfo* pinfo, char* buf, const uint32_t buflen); // cli
bool Deserialize(GameInfo* ginfo, char* buf, const uint32_t buflen); // cli
bool Deserialize(Chat* chat, char* buf, const uint32_t buflen); // srv/cli
bool Deserialize(ErrorLog* errlog, char* buf, const uint32_t buflen); // srv
bool Deserialize(Input* in, char* buf, uint32_t* buflen); // srv
bool Deserialize(Output* out, char* buf, uint32_t* buflen); // cli
bool Deserialize(Sync* sync, char* buf, uint32_t* buflen); // cli
bool Deserialize(TeamInfo* tinfo, char* buf, uint32_t* buflen); // cli/srv
bool Deserialize(LoginInfo* linfo, char* buf, uint32_t* buflen); // cli/srv
bool Deserialize(PlayerInfo* pinfo, char* buf, uint32_t* buflen); // cli
bool Deserialize(GameInfo* ginfo, char* buf, uint32_t* buflen); // cli
bool Deserialize(Chat* chat, char* buf, uint32_t* buflen); // srv/cli
bool Deserialize(ChunkMod* chmod, char* buf, uint32_t* buflen); // cli
bool Deserialize(PickupMod* chmod, char* buf, uint32_t* buflen); // cli
bool Deserialize(BulletAdd* bull, char* buf, uint32_t* buflen); // cli
bool Deserialize(ErrorLog* errlog, char* buf, uint32_t* buflen); // srv
PacketType getType(char* buf, uint32_t buflen); // srv/cli
PACKET_TYPE getType(char* buf, uint32_t buflen);
Packet getPack(char* buf, uint32_t *buflen);
Packet getPack(Buffer* buf);
bool emptyPack(Packet pck);
Packet makePack(void* ptr, PACKET_TYPE type); // Pour pouvoir faire une liste de stock a supprimer sans avoir a en faire une pour chaque type.
template <class T> T copyPack(Packet* pck);
template <class T> void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen);
template <class T> void sendPackTo(SOCKET sock, T* pack, char** buf, uint32_t* buflen, sockaddr_in* sockad);
template <class T> void sendPack(SOCKET sock, T* pack, Buffer* buf);
template <class T> void sendPackTo(SOCKET sock, T* pack, Buffer* buf, sockaddr_in* sockad);
void recvPacks(SOCKET sock, Buffer* buf, std::vector<char*>* lsPck);
void recvPacksFrom(SOCKET sock, Buffer* buf, sockaddr_in from, std::vector<char*>* lsPck);
/* Templates */
template <class T>
T copyPack(Packet* pck) { return T((T*)pck->ptr); }
template <class T>
void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen) {
netprot::Serialize(pack, buf, buflen);
memcpy(*buf + *buflen, Footer, sizeof(uint32_t));
*buflen += sizeof(Footer);
send(sock, *buf, *buflen, 0);
*buflen = BUFFER_LENGTH;
}
template <class T>
void sendPackTo(SOCKET sock, T* pack, char** buf, uint32_t* buflen, sockaddr_in* sockad) {
const sockaddr_in addr = *sockad;
netprot::Serialize(pack, buf, buflen);
memcpy(*buf + *buflen, Footer, sizeof(uint32_t));
*buflen += sizeof(Footer);
sendto(sock, *buf, *buflen, 0, (sockaddr*)&addr, sizeof(addr));
*buflen = BUFFER_LENGTH;
}
template <class T>
void sendPack(SOCKET sock, T* pack, Buffer* buf) {
netprot::Serialize(pack, &buf->ptr, &buf->len);
memcpy(&buf->ptr[buf->len], Footer, sizeof(uint32_t));
buf->len += sizeof(Footer);
send(sock, buf->ptr, buf->len, 0);
buf->rstLen();
}
template <class T>
void sendPackTo(SOCKET sock, T* pack, Buffer* buf, sockaddr_in* sockad) {
const sockaddr_in addr = *sockad;
netprot::Serialize(pack, &buf->ptr, &buf->len);
memcpy(&buf->ptr[buf->len], Footer, sizeof(uint32_t));
buf->len += sizeof(Footer);
sendto(sock, buf->ptr, buf->len, 0, (sockaddr*)&addr, sizeof(addr));
buf->rstLen();
}
};
#endif

View File

@ -4,25 +4,17 @@
Player::Player(const Vector3f& position, float rotX, float rotY) : m_position(position), m_rotX(rotX), m_rotY(rotY) {
m_velocity = Vector3f(0, 0, 0);
m_airborne = true;
m_hp = 0.75f; //TODO: Remettre à 1.0f
m_username = "Zelda Bee-Bop";
m_hp = 1.0f;
m_sensitivity = 0.5f;
m_username = "Zelda Bee-Bop56";
}
void Player::TurnLeftRight(float value) {
m_rotY += value;
Player::~Player() {}
void Player::TurnLeftRight(float value, float sensitivity) {
m_rotY += value * sensitivity;
if (m_rotY > 360) m_rotY = 0;
else if (m_rotY < -360) m_rotY = 0;
}
void Player::TurnTopBottom(float value) {
m_rotX += value;
if (m_rotX > 80) m_rotX = 80;
else if (m_rotX < -80) m_rotX = -80;
}
Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jump, bool shoot, float elapsedTime) {
Vector3f delta = Vector3f(0, 0, 0);
float yrotrad = (m_rotY / 57.2957795056f); // 180/Pi = 57.295...
float xrotrad = (m_rotX / 57.2957795056f);
@ -32,23 +24,44 @@ Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jum
cos(xrotrad) * -cos(yrotrad));
m_direction.Normalize();
}
void Player::TurnTopBottom(float value, float sensitivity) {
m_rotX += value * sensitivity;
if (m_rotX > 80) m_rotX = 80;
else if (m_rotX < -80) m_rotX = -80;
float yrotrad = (m_rotY / 57.2957795056f); // 180/Pi = 57.295...
float xrotrad = (m_rotX / 57.2957795056f);
m_direction = Vector3f(cos(xrotrad) * sin(yrotrad),
-sin(xrotrad),
cos(xrotrad) * -cos(yrotrad));
m_direction.Normalize();
}
Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jump, bool shoot, float elapsedTime) {
Vector3f delta = Vector3f(0, 0, 0);
Vector3f dir = m_direction;
dir.y = 0;
if (front) {
delta.x += float(sin(yrotrad)) * elapsedTime * 10.f;
delta.z += float(-cos(yrotrad)) * elapsedTime * 10.f;
delta += dir;
}
else if (back) {
delta.x += float(-sin(yrotrad)) * elapsedTime * 10.f;
delta.z += float(cos(yrotrad)) * elapsedTime * 10.f;
delta -= dir;
}
if (left) {
delta.x += float(-cos(yrotrad)) * elapsedTime * 10.f;
delta.z += float(-sin(yrotrad)) * elapsedTime * 10.f;
delta.x += dir.z;
delta.z += -dir.x;
}
else if (right) {
delta.x += float(cos(yrotrad)) * elapsedTime * 10.f;
delta.z += float(sin(yrotrad)) * elapsedTime * 10.f;
delta.x -= dir.z;
delta.z -= -dir.x;
}
delta.Normalize();
@ -59,9 +72,14 @@ Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jum
delta.y += jump ? .32f : shoot ? .1f : 0.f;
m_airborne = true;
}
if (boostspeed)
{
delta.x += STRENGTH_SPEED_BOOST / 100 * delta.x;
delta.z += STRENGTH_SPEED_BOOST / 100 * delta.z;
}
if (shoot) // Recoil!
TurnTopBottom(-1);
TurnTopBottom(-1, 1.0f);
return delta;
}
@ -105,32 +123,18 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi
bt1 = world->BlockAt(GetPosition().x + input.x, GetPosition().y, GetPosition().z);
bt2 = world->BlockAt(GetPosition().x + input.x, GetPosition().y - 0.9f, GetPosition().z);
bt3 = world->BlockAt(GetPosition().x + input.x, GetPosition().y - 1.7f, GetPosition().z);
if (bt1 == BTYPE_AIR && bt2 != BTYPE_AIR && bt3 != BTYPE_AIR) {
if (input.x > 0)
input.x = m_velocity.x = 0.5f;
else
input.x = m_velocity.x = -0.5f;
m_velocity.y = 0.3;
m_velocity.z *= .5f;
}
else if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
input.x = m_velocity.x = 0;
if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
m_velocity.y += .04f;
m_velocity.z *= .5f;
m_velocity.x *= .5f;
}
bt1 = world->BlockAt(GetPosition().x, GetPosition().y, GetPosition().z + input.z);
bt2 = world->BlockAt(GetPosition().x, GetPosition().y - 0.9f, GetPosition().z + input.z);
bt3 = world->BlockAt(GetPosition().x, GetPosition().y - 1.7f, GetPosition().z + input.z);
if (bt1 == BTYPE_AIR && bt2 != BTYPE_AIR && bt3 != BTYPE_AIR) {
if (input.z > 0)
input.z = m_velocity.z = 0.5f;
else
input.z = m_velocity.z = -0.5f;
m_velocity.y = 0.3;
m_velocity.x *= .5f;
}
else if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
input.z = m_velocity.z = 0;
if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
m_velocity.y += .04f;
m_velocity.z *= .5f;
m_velocity.x *= .5f;
}
@ -138,8 +142,8 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi
/* Gestion de la friction */
if (!m_airborne) {
m_velocity.x += input.x * 2.f * elapsedTime;
m_velocity.z += input.z * 2.f * elapsedTime;
m_velocity.x += input.x * (boostspeed ? 2.5f : 2.f) * elapsedTime;
m_velocity.z += input.z * (boostspeed ? 2.5f : 2.f) * elapsedTime;
if (input.x == 0.f)
m_velocity.x *= .8f;
@ -157,7 +161,7 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi
/* Fin gestion de la friction */
float vy = m_velocity.y;
m_velocity.y = 1.f; // Padding pour limiter le x et z lors du Normalize().
m_velocity.y = boostspeed ? 0.f: 1.f; // Padding pour limiter le x et z lors du Normalize().
if (m_velocity.Length() >= 1.f) m_velocity.Normalize(); // Limiteur de vitesse en x/z.
m_velocity.y = 0;
if (m_velocity.Length() < .005f) m_velocity.Zero(); // Threshold en x/z.
@ -165,7 +169,7 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi
m_position += m_velocity;
static float bobbingtime = 0; // Gestion de la caméra
static float bobbingtime = 0; // Gestion de la cam<EFBFBD>ra
static bool leftright = false;
static bool isStep = false;
if (bobbingtime <= 360.f)
@ -180,18 +184,87 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi
else isStep = false;
m_POV = m_position.y;
m_POV += m_airborne ? 0 : (sin(bobbingtime) - 0.5f) * (abs(m_velocity.x) + abs(m_velocity.z)) * .2f;
RemoveBooster(elapsedTime);
return snd;
}
void Player::ApplyTransformation(Transformation& transformation, bool rel) const {
void Player::Put(Vector3f pos) {
m_position = pos;
}
void Player::ApplyTransformation(Transformation& transformation, bool rel, bool rot) const {
transformation.ApplyRotation(-m_rotX, 1, 0, 0);
transformation.ApplyRotation(-m_rotY, 0, 1, 0);
if (rel) transformation.ApplyTranslation(-GetPOV());
}
uint64_t Player::TakeBooster(std::unordered_map<uint64_t, Booster*> booster_table, float elapsedtime)
{
uint64_t boostid = 0;
Vector3f playerpos = GetPosition();
for (auto& [key, booster]: booster_table) {
Vector3f pos = booster->GetPosition();
if (booster->GetAvailability() && abs(playerpos.x - pos.x) <= 0.5f && abs(playerpos.y - pos.y) <= 1.0f && abs(playerpos.z - pos.z) <= 0.5f)
{
boostid = booster->GetId();
GetBooster(booster->GetType(), elapsedtime);
booster->SetAvailability(false);
break;
}
}
return boostid;
}
void Player::GetBooster(BOOST_TYPE boosttype, float elapsedtime)
{
if (boosttype == BTYPE_SPEED)
{
boostspeed = true;
timeboostspeed = 0;
}
if (boosttype == BTYPE_HEAL)
{
m_hp = 1.0f;
}
if (boosttype == BTYPE_DAMAGE)
{
boostdamage = true;
timeboostdamage = 0;
}
if (boosttype == BTYPE_INVINCIBLE)
{
boostinvincible = true;
boostinvincible = 0;
}
}
void Player::RemoveBooster(float elapsedtime)
{
if (boostspeed)
{
timeboostspeed += elapsedtime;
if (timeboostspeed >= TIME_SPEED_BOOST && boostspeed == true)
boostspeed = false;
}
if (boostdamage)
{
if (timeboostdamage >= TIME_DAMAGE_BOOST && boostdamage == true)
boostdamage = false;
}
if (boostinvincible)
{
if (timeboostinvincible >= TIME_INVINCIBLE_BOOST && boostinvincible == true)
boostinvincible = false;
}
}
void Player::SetDirection(Vector3f dir) { m_direction = dir; }
void Player::Move(Vector3f diff) { m_position -= diff; }
Vector3f Player::GetPosition() const { return Vector3f(m_position.x + CHUNK_SIZE_X * WORLD_SIZE_X / 2, m_position.y, m_position.z + CHUNK_SIZE_Z * WORLD_SIZE_Y / 2); }
Vector3f Player::GetPositionAbs() const { return m_position; }
Vector3f Player::GetVelocity() const { return m_velocity; }
Vector3f Player::GetPOV() const { return Vector3f(GetPosition().x, m_POV, GetPosition().z); }
@ -200,9 +273,46 @@ Vector3f Player::GetDirection() const { return m_direction; }
std::string Player::GetUsername() const { return m_username; }
void Player::SetUsername(std::string username) {
m_username = username;
}
float Player::GetSensitivity() const {
return m_sensitivity;
}
void Player::SetSensitivity(float sensitivity) {
m_sensitivity = sensitivity;
}
float Player::GetHP() const { return m_hp; }
void Player::SetHP(float hp) {
m_hp = hp;
}
void Player::Teleport(int& x, int& z) {
m_position.x -= x * CHUNK_SIZE_X;
m_position.z -= z * CHUNK_SIZE_Z;
}
bool Player::GetIsAirborne() const { return m_airborne; }
bool Player::AmIDead() { return m_hp <= 0; }
void Player::InflictDamage(float hitPoints) {
m_hp -= hitPoints;
if (m_hp < 0)
m_hp == 0;
}
int Player::getScore() const { return m_score; }
void Player::addPoint() { ++m_score; }
uint64_t Player::getId() const { return id; }
Vector3f Player::InterpolatePosition(const Vector3f& vec1, const Vector3f& vec2, const Timestamp& tim1, const Timestamp& tim2, const Timestamp& now) {
return Vector3f();
}

View File

@ -2,44 +2,88 @@
#define PLAYER_H__
#include <cmath>
#include <unordered_map>
#include "transformation.h"
#include "vector3.h"
#include "booster.h"
#include "define.h"
class World;
class Player {
public:
enum Sound { NOSOUND, STEP, FALL };
//enum BoosterType { SPEED, HEAL, DAMAGE, INVINCIBLE };
Player(const Vector3f& position, float rotX = 0, float rotY = 0);
void TurnLeftRight(float value);
void TurnTopBottom(float value);
~Player();
void TurnLeftRight(float value, float sensitivity);
void TurnTopBottom(float value, float sensitivity);
Vector3f GetInput(bool front, bool back, bool left, bool right, bool jump, bool dash, float elapsedTime);
Sound ApplyPhysics(Vector3f input, World* world, float elapsedTime);
void ApplyTransformation(Transformation& transformation, bool rel = true) const;
uint64_t TakeBooster(std::unordered_map<uint64_t, Booster*> booster_table, float elapsedTime);
void GetBooster(BOOST_TYPE boosttype, float elapsedTime);
void RemoveBooster(float elapsedtime);
void ApplyTransformation(Transformation& transformation, bool rel = true, bool rot = true) const;
void SetDirection(Vector3f dir);
void Move(Vector3f diff);
Vector3f GetPosition() const;
Vector3f GetPositionAbs() const;
Vector3f GetDirection() const;
Vector3f GetVelocity() const;
Vector3f GetPOV() const;
std::string GetUsername() const;
void SetUsername(std::string username);
float GetSensitivity() const;
void SetSensitivity(float sensitivity);
float GetHP() const;
void SetHP(float hp);
void Teleport(int& x, int& z);
bool GetIsAirborne() const;
bool AmIDead();
void InflictDamage(float hitPoints);
int getScore() const;
void addPoint();
uint64_t Killer = 0;
std::string m_username;
bool m_hit = false;
bool Eulogy = false;
bool boostspeed = false;
bool boostdamage = false;
bool boostinvincible = false;
void Put(Vector3f pos);
private:
uint64_t getId() const;
protected:
Vector3f m_position;
Vector3f m_velocity;
Vector3f m_direction;
std::string m_username;
uint64_t id = 0;
int m_score = 0;
float m_rotX = 0;
float m_rotY = 0;
float m_POV;
float timeboostspeed;
float timeboostdamage;
float timeboostinvincible;
float m_sensitivity;
float m_hp;
bool m_airborne;
Vector3f InterpolatePosition(const Vector3f& vec1, const Vector3f& vec2, const Timestamp& tim1, const Timestamp& tim2, const Timestamp& now);
};
#endif //_PLAYER_H__

View File

@ -6,10 +6,19 @@ World::~World() {}
Array2d<Chunk*>& World::GetChunks() { return m_chunks; }
void World::BuildWorld() {
for (int x = 0; x < WORLD_SIZE_X; ++x)
for (int y = 0; y < WORLD_SIZE_Y; ++y)
m_chunks.Set(x, y, new Chunk(x + m_center[0], y + m_center[1], m_seed));
}
void World::SetSeed(uint64_t seed) {
m_seed = seed;
}
Chunk* World::ChunkAt(float x, float y, float z) const {
int cx = (int)x / CHUNK_SIZE_X;
int cz = (int)z / CHUNK_SIZE_Z;
@ -25,6 +34,30 @@ Chunk* World::ChunkAt(float x, float y, float z) const {
Chunk* World::ChunkAt(const Vector3f& pos) const { return ChunkAt(pos.x, pos.y, pos.z); }
void World::RemoveChunk(int nbReduit)
{
for (int x = 0; x < WORLD_SIZE_X; ++x)
for (int y = 0; y < WORLD_SIZE_Y; ++y)
{
Chunk* chk = nullptr;
if (x < nbReduit)
chk = m_chunks.Remove(x, y);
if (y < nbReduit)
chk = m_chunks.Remove(x, y);
if (y > WORLD_SIZE_Y - nbReduit)
chk = m_chunks.Remove(x, y);
if (x > WORLD_SIZE_X - nbReduit)
chk = m_chunks.Remove(x, y);
if (!chk)
continue;
m_tbDeleted.emplace_back(chk);
}
}
BlockType World::BlockAt(float x, float y, float z, BlockType defaultBlockType) const {
Chunk* c = ChunkAt(x, y, z);
@ -132,33 +165,27 @@ void World::GetScope(unsigned int& x, unsigned int& y) {
void World::Update(Bullet* bullets[MAX_BULLETS], const Vector3f& player_pos, BlockInfo* blockinfo[BTYPE_LAST]) {
UpdateWorld(player_pos, blockinfo);
//TransposeWorld(player_pos, bullets);
}
//
//void World::UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]) {
// if (updates == 0 && ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// ChunkAt(chx, 1, chy)->Update(blockinfo, this);
// updates = FRAMES_UPDATE_CHUNKS;
// }
//
//}
void World::ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block) {
netprot::ChunkMod* World::ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block, bool net) {
Vector3f currentPos = player_pos;
Vector3f currentBlock = currentPos;
Vector3f ray = player_dir;
BlockType oldbtype;
netprot::ChunkMod* cmod = nullptr;
bool found = false;
if (block) return;
if (block) return cmod;
while ((currentPos - currentBlock).Length() <= MAX_SELECTION_DISTANCE && !found) {
currentBlock += ray / 10.f;
BlockType bt = BlockAt(currentBlock);
if (bt != BTYPE_AIR)
if (bt != BTYPE_AIR) {
found = true;
oldbtype = bt;
}
}
if (found)
@ -184,21 +211,30 @@ void World::ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos,
(By == PyA ||
By == PyB ||
By == PyC) &&
Bz == Pz))
Bz == Pz)) {
found = true;
oldbtype = bt;
}
}
}
}
if (found && (int)currentBlock.y < CHUNK_SIZE_Y) {
if (net) {
cmod = new netprot::ChunkMod();
cmod->old_b_type = oldbtype;
cmod->b_type = blockType;
cmod->pos = currentBlock;
}
int bx = (int)currentBlock.x % CHUNK_SIZE_X;
int by = (int)currentBlock.y % CHUNK_SIZE_Y;
int bz = (int)currentBlock.z % CHUNK_SIZE_Z;
ChunkAt(currentBlock)->SetBlock(bx, by, bz, blockType, this);
ChunkAt(currentBlock)->MakeModified();
block = true;
}
return cmod;
}
void World::ChangeBlockAtPosition(BlockType blockType, Vector3f pos) {
@ -219,7 +255,6 @@ void World::UpdateWorld(const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]
int side = 0;
int threads = 0;
std::future<Chunk*> genThList[THREADS_GENERATE_CHUNKS];
//std::future<void> delThList[THREADS_DELETE_CHUNKS];
if (frameGenerate > 0) --frameGenerate;
if (frameUpdate > 0) --frameUpdate;
@ -310,101 +345,6 @@ void World::UpdateWorld(const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]
side = 0;
threads = 0;
//if (!frameUpdate)
// while (side * CHUNK_SIZE_X <= VIEW_DISTANCE * 2) {
// int tx = -side, ty = -side;
// for (; tx <= side; ++tx) {
// if (frameUpdate)
// break;
// unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
// if (ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// updateThList[threads++] =
// std::async(std::launch::async,
// [](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
// chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
// if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
// }
// }
// for (; ty <= side; ++ty) {
// if (frameUpdate)
// break;
// unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
// if (ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// updateThList[threads++] =
// std::async(std::launch::async,
// [](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
// chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
// if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
// }
// }
// for (; tx >= -side; --tx) {
// if (frameUpdate)
// break;
// unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
// if (ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// updateThList[threads++] =
// std::async(std::launch::async,
// [](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
// chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
// if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
// }
// }
// for (; ty >= -side; --ty) {
// if (frameUpdate)
// break;
// unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
// if (ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// updateThList[threads++] =
// std::async(std::launch::async,
// [](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
// chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
// if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
// }
// }
// if (frameUpdate)
// break;
// ++side;
// }
//if (threads > 0) {
// for (int i = 0; i < threads; ++i) {
// updateThList[i].wait();
// Chunk* chunk = updateThList[i].get();
// chunk->FlushMeshToVBO();
// }
//}
threads = 0;
//int del = THREADS_DELETE_CHUNKS;
//while (!m_tbDeleted.empty() && del--) { // Moins rapide que le bout en dessous, mais -beaucoup- plus stable.
// m_tbDeleted.back()->FlushVBO();
// m_tbDeleted.back()->~Chunk();
// m_tbDeleted.pop_back();
//}
/*while (!m_tbDeleted.empty() && !frameDelete) {
if (m_tbDeleted.back()) {
m_tbDeleted.back()->FlushVBO();
delThList[threads] =
std::async(std::launch::async,
[](Chunk* chunk) { delete chunk; }, m_tbDeleted.back());
m_tbDeleted.pop_back();
if (++threads > THREADS_DELETE_CHUNKS) frameDelete = FRAMES_DELETE_CHUNKS;
}
else m_tbDeleted.pop_back();
}*/
/*for (int x = 0; x < threads; ++x) {
delThList[x].wait();
delThList[x].get();
}*/
}
int World::GettbDeleted() const { return m_tbDeleted.size(); }

View File

@ -11,6 +11,7 @@
#include "array2d.h"
#include "bullet.h"
#include "chunk.h"
#include "netprotocol.h"
class Chunk;
class Bullet;
@ -21,12 +22,15 @@ public:
~World();
Array2d<Chunk*>& GetChunks();
void BuildWorld();
void SetSeed(uint64_t seed);
Chunk* ChunkAt(float x, float y, float z) const;
Chunk* ChunkAt(const Vector3f& pos) const;
void RemoveChunk(int nbReduit);
BlockType BlockAt(float x, float y, float z, BlockType defaultBlockType = BTYPE_AIR) const;
BlockType BlockAt(const Vector3f& pos, BlockType defaultBlockType = BTYPE_AIR) const;
@ -34,7 +38,7 @@ public:
void GetScope(unsigned int& x, unsigned int& y);
void ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block);
netprot::ChunkMod* ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block, bool net);
void ChangeBlockAtPosition(BlockType blockType, Vector3f pos);
void CleanUpWorld(int& deleteframes, bool clear);
int GettbDeleted() const;
@ -45,7 +49,7 @@ private:
unsigned int m_center[2] = { UINT16_MAX / 2 - WORLD_SIZE_X, UINT16_MAX / 2 - WORLD_SIZE_Y };
void UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]);
//void UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]);
void UpdateWorld(const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]);
void TransposeWorld(Vector3f& player, Bullet* bullets[MAX_BULLETS]);

View File

@ -76,6 +76,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -90,7 +91,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>Default</LanguageStandard>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -105,6 +106,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -119,6 +121,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>

View File

@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.18.4)
project(SQCSim-Server VERSION 0.1)
add_compile_options("-Wno-narrowing")
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_STANDARD_REQUIRED True)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "../out")

View File

@ -4,18 +4,18 @@
Connection::Connection(SOCKET sock,
sockaddr_in sockaddr,
netprot::LoginInfo log,
netprot::PlayerInfo play):
LoginInfo *log,
PlayerInfo *play) :
m_sock(sock),
m_addr(sockaddr),
m_loginfo(log),
m_playinfo(play) {
m_loginfo(*log),
m_playinfo(*play) {
}
Connection::~Connection() {
closesocket(m_sock);
}
delete player;
closesocket(m_sock); }
uint64_t Connection::GetHash(bool self) const { return self ? m_loginfo.sid : m_playinfo.id; }
@ -23,19 +23,17 @@ uint64_t Connection::GetTeamHash() const { return m_loginfo.tid; }
std::string Connection::GetName() const { return m_loginfo.name; }
void Connection::AddInput(netprot::Input in) {
m_input_manifest.insert({ in.timestamp, in });
}
void Connection::AddInput(Input in) { m_input_manifest.insert({ in.timestamp, in }); m_input_vector.push_back(in); }
netprot::Output* Connection::getOutput(Timestamp time) {
Output* Connection::getOutput(Timestamp time) {
auto out = m_output_manifest.find(time);
if (out != m_output_manifest.end())
return &out->second;
return nullptr;
}
netprot::Sync Connection::getSync(Timestamp time) {
netprot::Sync sync;
Sync Connection::getSync(Timestamp time) {
Sync sync;
auto out = m_output_manifest.find(time);
if (out != m_output_manifest.end()) {
sync.timestamp = out->second.timestamp;
@ -45,10 +43,205 @@ netprot::Sync Connection::getSync(Timestamp time) {
return sync;
}
void Connection::CleanInputManifest(Timestamp time) {
auto wat = m_input_manifest.find(time);
SOCKET Connection::getSock() const { return m_sock; }
while (wat != m_input_manifest.begin())
m_input_manifest.erase(wat--);
PlayerInfo* Connection::getInfo() const { return (PlayerInfo*)&m_playinfo; }
sockaddr_in* Connection::getAddr() const { return (sockaddr_in*)&m_addr; }
void Connection::getPacks(SOCKET sock) {
std::vector<char*> lsPck;
Input in;
Sync sync;
recvPacksFrom(sock, &m_buf, m_addr, &lsPck);
for (auto& pck : lsPck) {
uint32_t bsize = m_buf.len - (pck - m_buf.ptr);
switch (netprot::getType(pck, 1)) {
using enum netprot::PACKET_TYPE;
case INPUT:
if (player->AmIDead())
break;
else if (Deserialize(&in, pck, &bsize)) {
m_input_manifest[in.timestamp] = in;
m_input_vector.push_back(in);
}
break;
case SYNC:
if (Deserialize(&sync, pck, &bsize))
m_nsync = true;
break;
default: break;
}
}
lsPck.clear();
}
void Connection::sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns, const uint32_t timer) {
static int outs = 0;
static Timestamp last = 0;
static uint32_t lasttimer = timer;
if (m_output_vector.empty() && player->AmIDead()) {
if (timer != lasttimer) {
lasttimer = timer;
Sync sync;
sync.timestamp = sync.sid = m_loginfo.sid;
sync.hp = 0;
sync.ammo = -1;
sync.timer = timer;
sendPackTo<Sync>(sock, &sync, &m_bufout, &m_addr);
}
}
while (!m_output_vector.empty()) {
Output out = m_output_vector.front();
for (auto& [key, conn] : conns) {
if (m_playinfo.id == conn->GetHash(false))
continue;
sendPackTo<Output>(sock, &out, &m_bufout, conn->getAddr());
}
++outs;
[[unlikely]] if (last == 0) // !
last = out.timestamp;
outs += out.timestamp + last;
static bool syncdead = false;
bool dead = player->AmIDead();
if (outs >= SYNC_ACC || (!syncdead && dead)) {
Sync sync;
outs -= SYNC_ACC;
sync.timestamp = out.timestamp;
sync.position = out.position;
sync.sid = m_loginfo.sid;
sync.timer = timer;
sync.timestamp = out.timestamp;
sync.ammo = -1;
sync.hp = player->GetHP();
if (dead) {
sync.timestamp = m_loginfo.sid;
syncdead = true;
}
sendPackTo<Sync>(sock, &sync, &m_bufout, &m_addr);
}
m_output_vector.pop_front();
}
}
Timestamp Connection::Run(World* world, std::unordered_map<uint64_t, Booster*> boosters) {
Input in, last;
Output out;
Timestamp tstamp = 0;
float el;
bool dead = player->AmIDead();
if (m_input_manifest.size() < 2 && !dead)
return tstamp;
while (m_last_in < m_input_vector.size() - 1 || dead) {
if (!dead) {
in = m_input_vector.at(m_last_in + 1);
last = m_input_vector.at(m_last_in);
if (in.timestamp <= m_tstamp) {
++m_last_in;
continue;
}
el = (double)(in.timestamp - last.timestamp) / 1000.;
if (m_shoot_acc > 0.) {
m_shoot_acc -= el;
if (m_shoot_acc < 0.)
m_shoot_acc = 0.;
}
player->SetDirection(in.direction);
}
else {
el = 1. / 60.;
in = Input();
}
player->ApplyPhysics(player->GetInput(in.keys.forward,
in.keys.backward,
in.keys.left,
in.keys.right,
in.keys.jump, false, el),
world, el);
player->TakeBooster(boosters, el);
if (player->GetPosition().y < -20.) {
player->InflictDamage(9000.);
player->Killer = GetHash(true);
}
out.states.jumping = player->GetIsAirborne();
Vector3f horSpeed = player->GetVelocity();
horSpeed.y = 0;
out.states.running = horSpeed.Length() > .2f;
out.states.still = !out.states.running && !out.states.jumping;
out.states.hit = player->m_hit;
player->m_hit = false;
if (player->AmIDead()) {
in.keys.shoot = false;
in.keys.block = false;
out.states.dead = true;
}
static bool toggle = false;
if (in.keys.block) {
if (!toggle) {
toggle = true;
bool block = false;
ChunkMod* cmod = world->ChangeBlockAtCursor(BLOCK_TYPE::BTYPE_METAL,
player->GetPosition(),
player->GetDirection(),
block, true);
if (cmod)
ChunkDiffs.push_back(std::move(cmod));
}
}
else toggle = false;
out.states.shooting = in.keys.shoot;
if (out.states.jumping && out.states.shooting)
out.states.jumpshot = true;
else out.states.jumpshot = false;
if (in.keys.shoot && m_shoot_acc <= 0.) {
Bullets.emplace_back(new Bullet(player->GetPOV() + player->GetDirection(), player->GetDirection(), GetHash(true)));
m_shoot_acc = BULLET_TIME;
}
out.position = player->GetPositionAbs();
out.direction = in.direction;
out.timestamp = in.timestamp;
out.id = m_playinfo.id;
m_output_manifest[out.timestamp] = out;
m_output_vector.push_back(out);
m_tstamp = tstamp = out.timestamp;
if (!dead)
++m_last_in;
dead = false;
}
return tstamp;
}
void Connection::CleanInputManifest(Timestamp time) {
// auto wat = m_input_manifest.find(time);
// while (wat != m_input_manifest.begin())
// m_input_manifest.erase(wat--);
}
Timestamp Connection::GetTStamp() const { return m_tstamp; }

View File

@ -2,19 +2,22 @@
#define CONNECTION_H__
#include <deque>
#include <map>
#include <unordered_map>
#include "../SQCSim-common/player.h"
#include "../SQCSim-common/vector3.h"
#include "../SQCSim-common/netprotocol.h"
#include "../SQCSim-common/world.h"
#include "define.h"
using namespace netprot;
class Connection {
public:
Connection(
SOCKET sock,
sockaddr_in sockaddr,
netprot::LoginInfo log,
netprot::PlayerInfo play);
LoginInfo *log,
PlayerInfo *play);
~Connection();
Player* player = nullptr;
@ -23,20 +26,47 @@ public:
uint64_t GetTeamHash() const;
std::string GetName() const;
void AddInput(netprot::Input in);
netprot::Output* getOutput(Timestamp time);
netprot::Sync getSync(Timestamp time);
void AddInput(Input in);
Output* getOutput(Timestamp time);
Sync getSync(Timestamp time);
SOCKET getSock() const;
PlayerInfo* getInfo() const;
sockaddr_in* getAddr() const;
void getPacks(SOCKET sock);
void sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns, const uint32_t timer);
Timestamp Run(World* world, std::unordered_map<uint64_t, Booster*> boosters);
void CleanInputManifest(Timestamp time);
bool m_nsync = true;
std::vector<Bullet*> Bullets;
std::vector<ChunkMod*> ChunkDiffs;
Timestamp GetTStamp() const;
private:
std::map<Timestamp, netprot::Input> m_input_manifest;
std::map<Timestamp, netprot::Output> m_output_manifest;
std::map<Timestamp, netprot::Chat> m_chatlog;
std::unordered_map<Timestamp, Input> m_input_manifest;
std::vector<Input> m_input_vector;
std::unordered_map<Timestamp, Output> m_output_manifest;
std::deque<Output> m_output_vector;
std::unordered_map<Timestamp, Chat> m_chatlog;
float m_shoot_acc = 0;
Timestamp m_tstamp = 0;
SOCKET m_sock;
sockaddr_in m_addr;
netprot::LoginInfo m_loginfo;
netprot::PlayerInfo m_playinfo;
LoginInfo m_loginfo;
PlayerInfo m_playinfo;
Timestamp m_startsync;
uint64_t m_last_in = 0,
m_last_out = 0;
Buffer m_buf,
m_bufout;
};
#endif

View File

@ -9,9 +9,23 @@
#define MAX_CONNECTIONS 16
#define ID_LIST_SIZE 127
#define BUFFER_LENGTH 150
#define SRV_MANUAL_SETUP true
typedef unsigned char LogDest;
enum LOG_DEST { CONSOLE, LOGFILE, LOG_LAST };
// @ = Dead guy, $ = Killer.
const std::vector<std::string> DEATHMESSAGES = { "@ has gone to meet their maker.",
"@ has bit the dust, if you know what I mean.",
"@ has ceased to be.",
"@ is no more.",
"@ is like, super dead.",
"Requiescat In Pace, @.",
"So long, @, and thanks for all the lols!",
"@ has a bad case of being dead.",
"@ has finally seen the light!",
"$ sees dead people; in this case they see a dead @.",
"Thought @ was hot; guess what? He's not. He is dead, dead, dead.",
"@ did not want to live forever.",
"$ made @ die for their country.",
"$ has become death, destroyer of @.",
"$ did not make @ feel lucky." };
#endif

View File

@ -1,9 +1,13 @@
#include "server.h"
int main() {
Server* server = new Server();
std::unique_ptr<Server> server = std::make_unique<Server>();
if (server->Init() == 0)
if (server->Ready() == 0)
while (server->Ready() == 0) {
server->Run();
delete server;
if (!server->NewGameRequested())
break;
server->Cleanup();
}
server->DeInit();
}

View File

@ -1,6 +1,6 @@
#include "server.h"
Server::Server(LogDest log) {
Server::Server(LOG_DEST log) {
m_log = log;
if (log == LOG_DEST::LOGFILE) {
m_logfile = std::ofstream("server.log", std::ofstream::out);
@ -18,6 +18,10 @@ Server::~Server() {
closesocket(m_sock_udp);
if (m_sock_tcp)
closesocket(m_sock_tcp);
for (const auto& [key, player] : m_conns)
closesocket(player->getSock());
m_conns.clear();
delete m_world;
#ifdef _WIN32
WSACleanup();
#endif
@ -65,85 +69,458 @@ int Server::Init() {
}
int Server::Ready() {
int nbrjoueurs = 0,
nbrconn = 0;
bool readystart = false;
do {
Log("Entrez la duree de la partie: ", false, false);
std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
try {
m_game.countdown = std::stoi(m_buf.ptr);
}
catch (const std::exception& e) {
Log(e.what(), true, false);
m_game.countdown = 0;
}
} while (m_game.countdown < 1);
// m_game.seed = 9370707;
do {
Log("Entrez le seed de la partie: ", false, false);
std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
try {
m_game.seed = std::stoi(m_buf.ptr);
}
catch (const std::exception& e) {
Log(e.what(), true, false);
m_game.seed = 0;
}
} while (m_game.seed < 1);
do {
Log("Entrez le nombre de joueurs: ", false, false);
std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
try {
nbrjoueurs = std::stoi(m_buf.ptr);
}
catch (const std::exception& e) {
Log(e.what(), true, false);
nbrjoueurs = 0;
}
if (nbrjoueurs <= 0 || nbrjoueurs > MAX_CONNECTIONS)
Log("Nombre de joueurs invalide.", true, false);
} while (nbrjoueurs <= 0 || nbrjoueurs > MAX_CONNECTIONS);
do {
Log("Entrez le nombre de boosters: ", false, false);
std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
try {
m_boostcount = std::stoi(m_buf.ptr);
}
catch (const std::exception& e) {
Log(e.what(), true, false);
m_boostcount = -1;
}
} while (m_boostcount < 0);
m_game.gameType = 1;
if (listen(m_sock_tcp, MAX_CONNECTIONS) < 0) {
Log("Écoute sur le port TCP.", true, true);
Log("Ecoute sur le port TCP.", true, true);
return 1;
}
char* buf = new char[150];
uint32_t buflen = 150;
bool readystart = false;
srand(time(NULL));
Log("À l'écoute sur le port: " + std::to_string(SRV_PORT), false, false);
buildIdList(ID_LIST_SIZE);
m_game.countdown = 360;
m_game.gameType = 1;
m_game.seed = 9370707;
Log("A l'ecoute sur le port: " + std::to_string(SRV_PORT), false, false);
while (!readystart) {
sockaddr_in sockad;
unsigned int addrlen = sizeof(sockad);
addrlen_t addrlen = sizeof(sockad);
SOCKET sock = accept(m_sock_tcp, (sockaddr*)&sockad, &addrlen);
if (sock < 0)
Log("Erreur de connexion", true, false);
else if (sock > 0) {
std::string str = "Nouvelle connection provenant de: ";
char* strbuf = new char[BUFFER_LENGTH];
uint32_t strbuflen = BUFFER_LENGTH;
std::string str = "Nouvelle connexion provenant de: ";
str.append(inet_ntop(AF_INET, &sockad.sin_addr, m_buf.ptr, m_buf.len)).append(": ").append(std::to_string(sockad.sin_port));
str.append(inet_ntop(AF_INET, &sockad.sin_addr, strbuf, strbuflen)).append(": ").append(std::to_string(sockad.sin_port));
if (recv(sock, m_buf.ptr, m_buf.len, 0) > 0) {
PlayerInfo* play = new PlayerInfo();
if (recv(sock, buf, buflen, 0) > 0) {
netprot::LoginInfo log;
netprot::PlayerInfo play;
if (netprot::Deserialize(&log, buf, buflen)) {
log.sid = getUniqueId();
m_buf.len = BUFFER_LENGTH;
Packet pck = getPack(&m_buf);
if (pck.type != PACKET_TYPE::LOGINF) {
Log("Paquet invalide.", true, false);
if (pck.type != PACKET_TYPE::ERR)
netprot::emptyPack(pck);
continue; // Passer au prochain appel si c'est pas un LoginInfo ou un LoginInfo invalide qui rentre.
}
LoginInfo* log = (LoginInfo*)pck.ptr;
log.tid = 0;
log->sid = getUniqueId();
log->tid = 1145389380; // TODO: À changer si on implemente un mode en equipe.
str.append(" Nom: ").append(log.name);
Log(str, false, false);
str = "";
Log(str.append(" Nom: ").append(log->name), false, false);
str.clear();
str.append(log.name).append(" SID: [").append(std::to_string(log.sid).append("]"));
Log(str, false, false);
//netprot::Serialize(&log, &buf, &buflen);
//send(sock, buf, buflen, 0);
//buflen = 150;
sendPack<netprot::LoginInfo>(sock, &log, &buf, &buflen);
sendPackTo<LoginInfo>(m_sock_udp, log, &m_buf, &sockad);
play.id = getUniqueId();
memcpy(play.name, log.name, std::strlen(log.name) + 1);
play.tid = log.tid;
play->id = getUniqueId();
play->tid = log->tid;
strcpy(play->name, 32, log->name);
//netprot::Serialize(&m_game, &buf, &buflen);
//send(sock, buf, buflen, 0);
sendPack<netprot::GameInfo>(sock, &m_game, &buf, &buflen);
Log(str.append(play->name).append(" SID: [").append(std::to_string(log->sid)).append("]")
.append(" ID: [").append(std::to_string(play->id)).append("]")
.append(" TID: [").append(std::to_string(play->tid)).append("]"), false, false);
play->tid = log->tid;
sendPackTo<GameInfo>(m_sock_udp, &m_game, &m_buf, &sockad);
Connection* conn = new Connection(sock, sockad, log, play);
m_players[log.sid] = conn;
m_conns[log->sid] = conn;
if (++nbrconn >= nbrjoueurs)
readystart = true;
}
}
}
for (auto& [keyin, playin] : m_conns) // Not pretty, but it works.
for (auto& [keyout, playout] : m_conns) {
if (keyin == keyout)
continue;
sendPackTo<PlayerInfo>(m_sock_udp, playout->getInfo(), &m_buf, playin->getAddr()); // et envoyer les infos des joueurs distants au nouveau joueur.
}
return 0;
}
void Server::Run() {
bool endgame = false;
Input in;
sockaddr_in sockad;
addrlen_t socklen = sizeof(sockad);
Log("Partie en cours...", false, false);
Log("Debut de la partie...", false, false);
int players = m_conns.size();
m_world = new World();
m_world->SetSeed(m_game.seed);
m_world->GetChunks().Reset(nullptr);
m_world->BuildWorld();
for (auto& [key, conn] : m_conns) { // Creation des instances de joueurs et premier sync.
if (!conn) {
m_conns.erase(key);
continue;
}
int x = (rand() % (CHUNK_SIZE_X * WORLD_SIZE_X - 1) - (CHUNK_SIZE_X * WORLD_SIZE_X / 2)) / 4,
y = (rand() % (CHUNK_SIZE_Z * WORLD_SIZE_Y - 1) - (CHUNK_SIZE_Z * WORLD_SIZE_Y / 2)) / 4;
conn->player = new Player(Vector3f(x + .5f, CHUNK_SIZE_Y + 1.8f, y + .5f));
conn->player->m_username = conn->GetName();
m_players[key] = conn->player;
Sync sync;
sync.position = conn->player->GetPositionAbs();
sync.hp = conn->player->GetHP();
sync.sid = key;
sync.ammo = 0;
sync.timestamp = 0;
sync.timer = m_game.countdown;
sendPackTo<Sync>(m_sock_udp, &sync, &m_buf, conn->getAddr());
}
int timer = m_game.countdown, timer_acc = 0, deadplayers = 0;
std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
Timestamp last = 0;
std::vector<Chat*> chatlog;
std::vector<ChunkMod*> chunkdiffs;
std::vector<Bullet*> bullets;
std::vector<std::vector<Bullet*>::iterator> bullit;
std::vector<BulletAdd*> netbull;
std::vector<PickupMod*> netboosters;
std::vector<char*> lsPck;
int max = 0;
for (int64_t x = 0; x < m_boostcount; ++x) {
Vector3f pos = Vector3f(rand() % (WORLD_SIZE_X * CHUNK_SIZE_X) + .5f, rand() % CHUNK_SIZE_Y + .5f, rand() % (WORLD_SIZE_Y * CHUNK_SIZE_Z) + .5f);
if (m_world->BlockAt(pos) == BTYPE_AIR && m_world->BlockAt(Vector3f(pos.x, pos.y - 2, pos.z)) != BTYPE_AIR) {
Booster* boost = new Booster(pos, (BOOST_TYPE)(rand() % BTYPE_BOOST_LAST), getUniqueId());
m_boosters[boost->GetId()] = boost;
}
else --x;
if (++max > 100000)
break;
}
Chat* startchat = new Chat();
startchat->src_id = 0;
char startmess[] = "How would -YOU- like to die today, motherf-words?";
float endtime = 0.;
strcpy(startchat->mess, 140, startmess);
chatlog.emplace_back(startchat);
while (!endgame && endtime < 1.) {
using namespace std::chrono;
Timestamp tstamp = duration_cast<milliseconds>(high_resolution_clock::now() - start).count();
if (last == 0)
last = tstamp;
timer_acc += tstamp - last;
if (timer_acc >= 1000) {
while (timer_acc >= 1000)
timer_acc -= 1000;
if (!endgame)
--timer;
std::string str = "Timer: ";
Log(str.append(std::to_string(timer)), false, false);
}
last = tstamp;
for (auto& [key, conn] : m_conns) {
/* In */
Input in; Sync sync;
recvPacks(m_sock_udp, &m_buf, &lsPck);
for (auto& pck : lsPck) {
uint32_t bsize = m_buf.len - (pck - m_buf.ptr);
switch (netprot::getType(pck, 1)) {
using enum netprot::PACKET_TYPE;
case INPUT:
if (Deserialize(&in, pck, &bsize)) {
if (m_conns.count(in.sid))
m_conns[in.sid]->AddInput(in);
}
break;
case SYNC:
if (Deserialize(&sync, pck, &bsize)) {}
break;
default: break;
}
}
if (!lsPck.empty())
lsPck.clear();
/* Process */
if (conn->m_nsync) {
Timestamp tstamp = conn->Run(m_world, m_boosters);
if (conn->player->AmIDead() && !conn->player->Eulogy) {
Chat* chat = new Chat();
chat->dest_id = chat->dest_team_id = chat->src_id = 0;
Player* murderer = m_conns.at(conn->player->Killer)->player;
if (murderer != conn->player)
murderer->addPoint();
std::string killer = murderer->GetUsername();
std::string mess = getDeathMessage(conn->player->GetUsername(), killer);
strcpy(chat->mess, 140, mess.c_str());
chatlog.emplace_back(chat);
++deadplayers;
conn->player->Eulogy = true;
conn->m_nsync = false;
}
else {
for (auto& chmo : conn->ChunkDiffs)
chunkdiffs.emplace_back(std::move(chmo));
if (!conn->ChunkDiffs.empty())
conn->ChunkDiffs.clear();
for (auto& bull : conn->Bullets) {
bullets.emplace_back(bull);
BulletAdd* nbul = new BulletAdd();
nbul->pos = bull->getPos();
nbul->dir = bull->getVel();
nbul->id = key;
nbul->tstamp = tstamp;
netbull.emplace_back(std::move(nbul));
}
if (!conn->Bullets.empty())
conn->Bullets.clear();
}
}
/* Out */
conn->sendPacks(m_sock_udp, m_conns, timer);
if ((deadplayers == players - 1 && deadplayers != 0) || timer < 0) {
if (!endgame) {
Chat* gameover = new Chat();
gameover->dest_id = gameover->dest_team_id = gameover->src_id = 0;
std::string winner, winmess;
int score = 0;
bool plural = false;
for (auto& [key, conn] : m_conns) {
if (conn->player->getScore() > score) {
winner = conn->player->GetUsername();
score = conn->player->getScore();
plural = false;
}
else if (conn->player->getScore() == score) {
winner = winner.append(" and ").append(conn->player->GetUsername());
plural = true;
}
}
winmess = "And the winner";
if (!plural)
winmess = winmess.append(" is ");
else winmess = winmess.append("s are ");
winmess = winmess.append(winner).append(" with ").append(std::to_string(score)).append(" point");
if (score > 1)
winmess = winmess.append("s.");
else winmess = winmess.append(".");
strcpy(gameover->mess, 140, winmess.c_str());
chatlog.emplace_back(gameover);
}
endgame = true;
endtime += .001;
}
}
int max = 0;
for (auto& [key, booster] : m_boosters) {
if (booster->modified) {
PickupMod pmod;
pmod.available = booster->GetAvailability();
pmod.id = booster->GetId();
pmod.pos = booster->GetPosition();
Boosts boost;
switch (booster->GetType()) {
case BTYPE_DAMAGE:
boost.damage = true;
break;
case BTYPE_HEAL:
boost.hp = true;
break;
case BTYPE_INVINCIBLE:
boost.invincible = true;
break;
default: continue;
}
pmod.boost = boost;
booster->modified = false;
for (auto& [key, conn] : m_conns)
sendPackTo<PickupMod>(m_sock_udp, &pmod, &m_buf, conn->getAddr());
max++;
if (max > 5)
break;
}
}
for (auto& bull : netbull) {
for (auto& [key, conn] : m_conns)
if (bull->id != conn->GetHash(false)) // Pour pas repitcher au joueur sa propre balle.
sendPackTo<BulletAdd>(m_sock_udp, bull, &m_buf, conn->getAddr());
delete bull;
}
if (!netbull.empty())
netbull.clear();
for (auto bull = bullets.begin(); bull != bullets.end(); ++bull) {
ChunkMod* cmod = nullptr;
Bullet* bullet = *bull;
if (bullet->Update(m_world, (1. / 60.), 50, m_players, &cmod)) {
if (cmod)
chunkdiffs.emplace_back(cmod);
bullit.push_back(bull);
}
}
for (auto& bull : bullit) {
delete* bull;
bullets.erase(bull);
}
if (!bullit.empty())
bullit.clear();
for (auto& chat : chatlog) {
Log(chat->mess, false, false);
for (auto& [key, conn] : m_conns)
sendPackTo<Chat>(m_sock_udp, chat, &m_buf, conn->getAddr());
delete chat;
}
if (!chatlog.empty())
chatlog.clear();
for (auto& chmo : chunkdiffs) {
for (auto& [key, conn] : m_conns)
sendPackTo<ChunkMod>(m_sock_udp, chmo, &m_buf, conn->getAddr());
delete chmo;
}
if (!chunkdiffs.empty())
chunkdiffs.clear();
}
Chat end;
end.src_id = 0;
char endmess[] = "Game over, man. Game over.";
strcpy(end.mess, 140, endmess);
for (auto& [key, conn] : m_conns) {
std::string str = conn->player->GetUsername();
Log(str.append(" ").append(std::to_string(conn->player->getScore())), false, false);
}
for (auto& [key, conn] : m_conns)
sendPackTo<Chat>(m_sock_udp, &end, &m_buf, conn->getAddr());
// TODO: Gérer les 2-3 secondes post-game avant le billboard pour pas avoir un whiplash à la fin de la game.
char* ch = new char[2];
std::cout << "Nouvelle partie? [o/N] ";
std::cin.getline(ch, 2);
std::cout << std::endl;
m_exit = true;
if (ch[0] == 'o' || ch[0] == 'O')
m_exit = false;
delete[] ch;
}
void Server::Cleanup() {
for (auto& [key, conn] : m_conns)
delete conn;
m_conns.clear();
m_players.clear();
delete m_world;
m_world = nullptr;
}
void Server::DeInit() {
if (m_logfile.is_open())
m_logfile.close();
if (m_sock_udp)
closesocket(m_sock_udp);
if (m_sock_tcp)
closesocket(m_sock_tcp);
#ifdef _WIN32
WSACleanup();
#endif
}
bool Server::NewGameRequested() const { return !m_exit; }
inline std::string Server::LogTimestamp() {
time_t rawtime;
struct tm timeinfo;
char buffer[80];
tm timeinfo;
char buffer[50];
time(&rawtime);
@ -161,30 +538,40 @@ inline std::string Server::LogTimestamp() {
void Server::Log(std::string str, bool is_error = false, bool is_fatal = false) {
switch (m_log) {
case LOG_DEST::LOGFILE:
using enum LOG_DEST; // C++20!
case LOGFILE:
m_logfile << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
break;
case LOG_DEST::CONSOLE:
case CONSOLE: [[fallthrough]]; // Pour dire que c'est voulu que ça traverse vers le case en dessous (C++17!)
default:
std::cout << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
break;
}
if (is_fatal) {
if (m_logfile.is_open())
m_logfile.close();
if (m_sock_udp)
closesocket(m_sock_udp);
if (m_sock_tcp)
closesocket(m_sock_tcp);
for (const auto& [key, player] : m_conns)
closesocket(player->getSock());
delete m_world;
m_conns.clear();
#ifdef _WIN32
WSACleanup();
#endif
exit(-1);
}
}
void Server::buildIdList(size_t size) {
std::set<uint64_t> lst;
do lst.insert(((uint64_t)rand() << 25) % 8675309); // EIGHT SIX SEVENFIVE THREE AUGHT NIIIIIIiIIiiIiINE!
srand(time(NULL));
do lst.insert(((uint64_t)rand() << 32 | rand()));
while (lst.size() < size);
m_ids = std::vector<uint64_t>(lst.begin(), lst.end());
@ -196,132 +583,33 @@ uint64_t Server::getUniqueId() {
return id;
}
// Test serialize/deserialize:
/*
netprot::LoginInfo log, log2;
std::cout << "Nom? ";
std::cin.getline(log.name, 32); // NO! STD::CIN >> VARIABLE;! EVEEEEEERRRR!!!
log.sid = 12345;
char* buf = new char[150];
uint32_t buflen = 150;
std::string Server::getDeathMessage(std::string username, std::string killer) const {
std::string mess;
std::string temp = DEATHMESSAGES.at(rand() % DEATHMESSAGES.size());
size_t ind = temp.find('@');
size_t indk = temp.find('$');
bool bypass = false;
netprot::Serialize(&log, &buf, &buflen);
if (indk == std::string::npos)
bypass = true;
bool is_work = netprot::Deserialize(&log2, buf, buflen);
if (ind < indk || bypass) {
mess.append(temp.substr(0, ind));
mess.append(username);
if (!bypass) {
mess.append(temp.substr(ind + 1, indk - 1));
mess.append(killer);
mess.append(temp.substr(indk + 1));
}
else mess.append(temp.substr(ind + 1));
}
else {
mess.append(temp.substr(0, indk));
mess.append(killer);
mess.append(temp.substr(indk + 1, ind - 1));
mess.append(username);
mess.append(temp.substr(ind + 1));
}
std::string str;
str.append(is_work ? "Y " : "N ").append(log2.name).append(": ").append(std::to_string(log2.sid));
Log(str, false, false);
*/
///* Recevoir paquet */
//while (true) {
// char buffer[2048];
// sockaddr_in client;
//
//#ifdef _WIN32 // Mais pourquoi?
// int clen = sizeof(client);
//#else
// unsigned int clen = sizeof(client);
//#endif
//
// int count = recvfrom(socket_udp, buffer, sizeof(buffer) - 1, 0, (sockaddr*)&client, &clen);
//
// if (count < 0) {
// Log("Erreur de reception de paquet.", socket_udp);
// return 4;
// }
//
// buffer[count] = '\0';
//
// /* Gérer le paquet reçu */
// std::string commande(buffer);
//
// if (commande.find("echo ") == 0) { /* ECHO */
// std::string::size_type pos = commande.find(' ');
// std::string parametres = commande.substr(pos + 1);
//
// sendto(socket_udp, parametres.c_str(), parametres.length(), 0, (const sockaddr*)&client, sizeof(client));
// }
// else if (commande.find("date ") == 0) { /* DATE */
// time_t rawtime;
// struct tm* timeinfo = new tm();
// char tbuffer[80];
//
// time(&rawtime);
//
//#ifdef _WIN32
// localtime_s(timeinfo, &rawtime);
//#else
// localtime_r(&rawtime, timeinfo);
//#endif
//
// strftime(tbuffer, 80, "%a %b %e %T %G", timeinfo);
//
// sendto(socket_udp, tbuffer, sizeof(tbuffer), 0, (const sockaddr*)&client, sizeof(client));
// delete timeinfo;
// }
// else if (commande.find("ping ") == 0) { /* PING */
// sendto(socket_udp, "pong", sizeof("pong"), 0, (const sockaddr*)&client, sizeof(client));
// }
// else if (commande.find("usager ") == 0) { /* USAGER */
// std::string user;
//
//#ifdef _WIN32
// wchar_t userbuf[30];
// DWORD usersize = 30;
//
// GetUserNameW(userbuf, &usersize);
//
// std::wstring wuser = userbuf;
// user = std::string(wuser.begin(), wuser.end());
//#else
// char ptr[30];
// getlogin_r(ptr, sizeof(ptr) - 1);
// user = std::string(ptr);
//#endif
//
// sendto(socket_udp, user.c_str(), user.length(), 0, (const sockaddr*)&client, sizeof(client));
// }
// else if (commande.find("exec ") == 0) { /* EXEC */
// std::string::size_type pos = commande.find(' ');
// std::string parametres = commande.substr(pos + 1);
//
// FILE* pipe = nullptr;
// char buffer[301]; // 300 caractères + '\0'
// std::string reponse;
//
// pipe = popen(parametres.c_str(), "r");
//
// if (!pipe)
// reponse = "Erreur de commande!";
// else while (!feof(pipe)) {
// if (fgets(buffer, sizeof(buffer) - 1, pipe))
// reponse += buffer;
// }
//
// if (pipe)
// pclose(pipe);
//
// if (reponse.length() > 300)
// reponse = reponse.substr(0, 300);
// else if (reponse.length() < 1)
// reponse = "OK!";
//
// sendto(socket_udp, reponse.c_str(), reponse.length(), 0, (const sockaddr*)&client, sizeof(client));
// }
// else if (commande.find("bye ") == 0) { /* BYE */
// Log("", 0); // Message d'erreur pas de message d'erreur!
// return 0;
// }
// else sendto(socket_udp, "huh?", sizeof("huh?"), 0, (const sockaddr*)&client, sizeof(client)); /* DEFAULT */
//}
//
///* Ce bout de code ne devrait theoriquement jamais etre atteint, mais au cas. */
//Log("", 0);
//return 0;
//return false;
//}
//
return mess;
}

View File

@ -1,54 +1,64 @@
#ifndef SERVER_H__
#define SERVER_H__
#include <cstdlib>
#include <fstream>
#include <vector>
#include <set>
#include <string>
#include <unordered_map>
#include "../SQCSim-common/world.h"
#include "../SQCSim-common/netprotocol.h"
#include "define.h"
#include "connection.h"
using namespace netprot;
class Server {
public:
Server(LogDest log = LOG_DEST::CONSOLE);
enum LOG_DEST: unsigned char { CONSOLE, LOGFILE, LOG_LAST };
Server(LOG_DEST log = LOG_DEST::CONSOLE);
~Server();
int Init();
int Ready();
void Run();
void Cleanup();
void DeInit();
bool NewGameRequested() const;
private:
#ifdef _WIN32
WSADATA m_wsaData;
#endif
SOCKET m_sock_udp = 0,
m_sock_tcp = 0;
LogDest m_log;
LOG_DEST m_log;
std::ofstream m_logfile;
std::map<uint64_t, Connection*> m_players;
std::map <Timestamp, netprot::Chat> m_chatlog;
Buffer m_buf;
std::unordered_map<uint64_t, Player*> m_players;
std::unordered_map<uint64_t, Connection*> m_conns;
std::unordered_map<Timestamp, Chat> m_chatlog;
std::unordered_map<uint64_t, Booster*> m_boosters;
std::vector<uint64_t> m_ids;
netprot::GameInfo m_game;
GameInfo m_game;
World* m_world = nullptr;
bool m_exit = true;
int64_t m_boostcount = -1;
std::string LogTimestamp();
void Log(std::string str, bool is_error, bool is_fatal);
void buildIdList(size_t size);
uint64_t getUniqueId();
template <class T> void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen);
std::string getDeathMessage(std::string username, std::string killer) const;
};
template <class T>
void Server::sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen) {
netprot::Serialize(pack, buf, buflen);
send(sock, *buf, *buflen, 0);
*buflen = BUFFER_LENGTH;
}
#endif

View File

@ -25,13 +25,15 @@
<ClInclude Include="engine.h" />
<ClInclude Include="mesh.h" />
<ClInclude Include="openglcontext.h" />
<ClInclude Include="remoteplayer.h" />
<ClInclude Include="settings.h" />
<ClInclude Include="shader.h" />
<ClInclude Include="skybox.h" />
<ClInclude Include="texture.h" />
<ClInclude Include="textureatlas.h" />
<ClInclude Include="tool.h" />
<ClInclude Include="vertexbuffer.h" />
<ClInclude Include="worldrenderer.h" />
<ClInclude Include="renderer.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="audio.cpp" />
@ -40,13 +42,15 @@
<ClCompile Include="main.cpp" />
<ClCompile Include="mesh.cpp" />
<ClCompile Include="openglcontext.cpp" />
<ClCompile Include="remoteplayer.cpp" />
<ClCompile Include="settings.cpp" />
<ClCompile Include="shader.cpp" />
<ClCompile Include="skybox.cpp" />
<ClCompile Include="texture.cpp" />
<ClCompile Include="textureatlas.cpp" />
<ClCompile Include="tool.cpp" />
<ClCompile Include="vertexbuffer.cpp" />
<ClCompile Include="worldrenderer.cpp" />
<ClCompile Include="renderer.cpp" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\SQCSim-common\SQCSim-common.vcxproj">
@ -105,8 +109,8 @@
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<IncludePath>external\irrKlang-1.6.0\include;external\glew210\include;external\devil178\include;external\sfml251\include;$(IncludePath)</IncludePath>
<LibraryPath>external\glew210\lib;external\sfml251\lib;external\devil178\lib;external\irrKlang-1.6.0\lib\Win32-visualStudio;$(LibraryPath)</LibraryPath>
<IncludePath>external\irrKlang-1.6.0\include;external\glew210\include;external\devil180\include;external\sfml251-32\include;$(IncludePath)</IncludePath>
<LibraryPath>external\glew210\lib\Release\Win32;external\sfml251-32\lib;external\devil180\lib\x86\Release;external\irrKlang-1.6.0\lib\Win32-visualStudio;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
@ -115,8 +119,8 @@
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<IncludePath>external\devil180\include;external\irrKlang-1.6.0\include;external\sfml251\include;external\glew210\include;$(IncludePath)</IncludePath>
<LibraryPath>external\sfml251\lib;external\devil180\lib\x86\Release;external\glew210\lib\Release\Win32;$(LibraryPath);external\irrKlang-1.6.0\lib\Win32-visualStudio</LibraryPath>
<IncludePath>external\devil180\include;external\irrKlang-1.6.0\include;external\sfml251-32\include;external\glew210\include;$(IncludePath)</IncludePath>
<LibraryPath>external\sfml251-32\lib;external\devil180\lib\x86\Release;external\glew210\lib\Release\Win32;$(LibraryPath);external\irrKlang-1.6.0\lib\Win32-visualStudio</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
@ -130,7 +134,7 @@
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<LanguageStandard>stdcpp17</LanguageStandard>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -145,7 +149,7 @@
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<LanguageStandard>stdcpp17</LanguageStandard>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -162,13 +166,13 @@
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<LanguageStandard>stdcpp17</LanguageStandard>
<LanguageStandard>stdcpp20</LanguageStandard>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<FloatingPointModel>Fast</FloatingPointModel>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
@ -184,7 +188,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<LanguageStandard>stdcpp17</LanguageStandard>
<LanguageStandard>stdcpp20</LanguageStandard>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<FloatingPointModel>Fast</FloatingPointModel>

View File

@ -47,7 +47,13 @@
<ClInclude Include="mesh.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="worldrenderer.h">
<ClInclude Include="renderer.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="remoteplayer.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="settings.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
</ItemGroup>
@ -88,7 +94,13 @@
<ClCompile Include="mesh.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="worldrenderer.cpp">
<ClCompile Include="renderer.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="remoteplayer.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="settings.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
</ItemGroup>

View File

@ -8,30 +8,46 @@ Audio::Audio() {
m_engine->setDefault3DSoundMaxDistance(1000);
}
Audio::Audio(const char * music) {
Audio::Audio(const char * music, const char* menumusic) {
m_engine = irrklang::createIrrKlangDevice();
m_engine->setDopplerEffectParameters(1);
m_engine->setRolloffFactor(1);
m_engine->setDefault3DSoundMinDistance(1);
m_engine->setDefault3DSoundMaxDistance(1000);
m_music = m_engine->play2D(music, false, true, true, irrklang::ESM_STREAMING);
m_engine->setDefault3DSoundMaxDistance(100);
m_music = m_engine->play2D(music, true, true, true, irrklang::ESM_STREAMING);
m_menumusic = m_engine->play2D(menumusic, true, true, true, irrklang::ESM_STREAMING);
m_music->setVolume(.5);
m_menumusic->setVolume(.5);
m_mainvolume = 0.5f;
m_engine->setSoundVolume(m_mainvolume);
m_sfxvolume = 0.5f;
}
Audio::~Audio() {
if (m_music) m_music->drop();
if (m_menumusic) m_menumusic->drop();
if (m_engine) m_engine->drop();
}
void Audio::playSound(const char* name, float volume = 1.) {
irrklang::ISound* sfx = m_engine->play2D(name, false, true);
sfx->setVolume(volume);
sfx->setIsPaused(false);
m_sfxes.push_back(sfx);
}
void Audio::Update3DAudio(Vector3f pos, Vector3f dir, Vector3f vel) {
m_engine->setListenerPosition(irrklang::vec3df(pos.x, pos.y, pos.z),
irrklang::vec3df(dir.x, dir.y, dir.z),
irrklang::vec3df(vel.x, vel.y, vel.z));
}
void Audio::Create3DAudioObj(irrklang::ISound* sound, const char* name, Vector3f pos, Vector3f vel, float volume = 1) {
sound = m_engine->play3D(name, irrklang::vec3df(pos.x, pos.y, pos.z), false, false, true, irrklang::ESM_NO_STREAMING, true);
irrklang::ISound* Audio::Create3DAudioObj(irrklang::ISound* sound, const char* name, Vector3f pos, Vector3f vel, bool is_looped = false, float volume = 1) {
sound = m_engine->play3D(name, irrklang::vec3df(pos.x, pos.y, pos.z), is_looped, true, true, is_looped? irrklang::ESM_STREAMING: irrklang::ESM_NO_STREAMING, true);
sound->setVelocity(irrklang::vec3df(vel.x, vel.y, vel.z));
sound->setVolume(volume);
sound->setIsPaused(false);
return sound;
}
void Audio::Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& vel, float volume = 1) {
@ -44,6 +60,76 @@ void Audio::Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& v
// m_music = m_engine->play2D(music, false, false, false, irrklang::ESM_STREAMING);
//}
void Audio::ToggleMusicState() { m_music->setIsPaused(!m_music->getIsPaused()); }
void Audio::CleanupSFX() {
while (!m_sfxes.empty()) {
irrklang::ISound* sfx = m_sfxes.back();
if (sfx->isFinished()) {
sfx->drop(); // drop() fait deja la job du delete sfx.
}
else break;
m_sfxes.pop_back();
}
}
void Audio::ToggleMusicState(GameState state) {
if (m_music_on) {
switch (state) {
case PLAY:
m_music->setIsPaused(false);
m_menumusic->setIsPaused(true);
break;
case PAUSE:
m_music->setIsPaused(true);
m_menumusic->setIsPaused(true);
break;
default:
m_music->setIsPaused(true);
m_menumusic->setIsPaused(false);
break;
}
}
else {
m_music->setIsPaused(true);
m_menumusic->setIsPaused(true);
}
}
void Audio::SetMusic(bool ison, GameState state) {
m_music_on = state;
if (!state) {
m_music->setIsPaused(true);
m_menumusic->setIsPaused(true);
}
else ToggleMusicState(state);
}
bool Audio::GetMusic() {
return m_music_on;
}
void Audio::PauseEngine() { m_engine->setAllSoundsPaused(); }
float Audio::GetMusicVolume() const {
return m_music->getVolume();
}
void Audio::SetMusicVolume(float volume) {
m_music->setVolume(volume);
m_menumusic->setVolume(volume);
}
float Audio::GetMainVolume() const {
return m_engine->getSoundVolume();
}
void Audio::SetMainVolume(float volume) {
m_engine->setSoundVolume(volume);
}
float Audio::GetSfxVolume() const {
return m_sfxvolume;
}
void Audio::SetSfxVolume(float volume) {
m_sfxvolume = volume;
}

View File

@ -14,25 +14,47 @@
class Audio {
private:
irrklang::ISoundEngine* m_engine;
irrklang::ISound* m_music;
irrklang::ISound* m_menumusic;
float m_mainvolume;
float m_sfxvolume;
bool m_music_on = true;
std::vector<irrklang::ISound*> m_sfxes;
public:
Audio();
Audio(const char* music);
Audio(const char* music, const char* menumusic);
~Audio();
irrklang::ISoundEngine* m_engine;
void Update3DAudio(Vector3f pos, Vector3f dir, Vector3f speed);
void Create3DAudioObj(irrklang::ISound* sound, const char* name, Vector3f pos, Vector3f vel, float volume);
irrklang::ISound* Create3DAudioObj(irrklang::ISound* sound, const char* name, Vector3f pos, Vector3f vel, bool is_looped, float volume);
void Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& vel, float volume);
//void PlaySong(const char* music);
void ToggleMusicState();
void CleanupSFX();
void ToggleMusicState(GameState state);
void playSound(const char* sound, float volume);
void SetMusic(bool ison, GameState state);
bool GetMusic();
void PauseEngine();
float GetMainVolume() const;
void SetMainVolume(float volume);
float GetMusicVolume() const;
void SetMusicVolume(float volume);
float GetSfxVolume() const;
void SetSfxVolume(float volume);
};
#endif // AUDIO_H__

View File

@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.18.4)
project(SQCSim-Client VERSION 0.8)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_STANDARD_REQUIRED True)
set(CMAKE_BUILD_DIRECTORY "./build")
@ -28,6 +28,7 @@ include_directories(
add_library(SQCSim-common
"${SQCSIM_COMMON_DIR}boostinfo.cpp"
"${SQCSIM_COMMON_DIR}blockinfo.cpp"
"${SQCSIM_COMMON_DIR}bullet.cpp"
"${SQCSIM_COMMON_DIR}chunk.cpp"
@ -40,6 +41,7 @@ add_library(SQCSim-common
add_executable(SQCSim-client
"../audio.cpp"
"../booster.cpp"
"../connector.cpp"
"../engine.cpp"
"../mesh.cpp"
@ -50,7 +52,8 @@ add_executable(SQCSim-client
"../textureatlas.cpp"
"../tool.cpp"
"../vertexbuffer.cpp"
"../worldrenderer.cpp"
"../renderer.cpp"
"../remoteplayer.cpp"
"../main.cpp"
)

View File

@ -42,7 +42,7 @@ int Connector::Init() {
return 0;
}
int Connector::Connect(char* srv_addr, std::string name) {
int Connector::Connect(const char* srv_addr, std::string name) {
sockaddr_in add;
m_srvsockaddr.sin_family = AF_INET;
m_srvsockaddr.sin_port = htons(SRV_PORT);
@ -54,48 +54,71 @@ int Connector::Connect(char* srv_addr, std::string name) {
if (connect(m_sock_tcp, (sockaddr*)&m_srvsockaddr, sizeof(m_srvsockaddr)) < 0) {
std::cout << "Échec de la connexion." << std::endl;
}
char* buf = new char[150];
uint32_t buflen = 150;
netprot::LoginInfo log;
memcpy(&log.name, name.c_str(), name.size() + 1);
netprot::Serialize(&log, &buf, &buflen);
int se = send(m_sock_tcp, buf, buflen, 0);
delete[] buf;
buf = new char[150] {0};
buflen = 150;
int rpack = 0;
while (rpack < 2) {
recv(m_sock_tcp, buf, buflen, 0);
switch (netprot::getType(buf, buflen)) {
case netprot::PACKET_TYPE::LOGINF:
if (!netprot::Deserialize(&m_loginfo, buf, buflen)) {
std::cout << "Packet LoginInfo invalide." << std::endl;
return 2;
}
++rpack;
break;
case netprot::PACKET_TYPE::GAMEINFO:
if (!netprot::Deserialize(&m_gameinfo, buf, buflen)) {
std::cout << "Packet GameInfo invalide." << std::endl;
flag_t flag = 1;
if (ioctl(m_sock_tcp, SOCK_NONBLOCK, &flag) < 0) {
std::cout << "Impossible de mettre le socket en mode non-bloquant." << std::endl;
return 3;
}
++rpack;
netprot::Buffer bf;
netprot::LoginInfo log;
strcpy(log.name, 32, name.c_str());
netprot::sendPack(m_sock_tcp, &log, &bf);
bool ready = false;
int errors = 0;
std::vector<char*> lsPck;
while (!ready) {
netprot::recvPacks(m_sock_udp, &bf, &lsPck);
for (auto& pck : lsPck) {
uint32_t bsize = bf.len - (pck - bf.ptr);
netprot::PlayerInfo* pl = nullptr;
switch (netprot::getType(pck, 1)) {
using enum netprot::PACKET_TYPE;
case LOGINF:
if (!netprot::Deserialize(&m_loginfo, pck, &bsize))
++errors;
break;
case GAMEINFO:
if (!netprot::Deserialize(&m_gameinfo, pck, &bsize))
++errors;
break;
case PLAYINF:
pl = new netprot::PlayerInfo();
if (!netprot::Deserialize(pl, pck, &bsize))
++errors;
else {
m_players[pl->id] = pl;
std::cout << "A challenger appears! " << pl->name << std::endl;
}
break;
case TEAMINF:
// TODO: Faire dequoi avec TeamInfo si on fini par avoir des teams.
break;
case SYNC:
if (!netprot::Deserialize(&m_origin, pck, &bsize))
++errors;
ready = true;
break;
default:
std::cout << "Packet invalide." << std::endl;
errors++;
break;
}
}
lsPck.clear();
if (errors > 1000)
return 4;
}
return 0;
}
uint64_t Connector::getId() const { return m_loginfo.sid; }
unsigned int Connector::getSeed() const { return m_gameinfo.seed; }
netprot::Sync Connector::getOrigin() const { return m_origin; }

View File

@ -2,6 +2,7 @@
#define CONNECTOR_H__
#include <stdlib.h>
#include <unordered_map>
#include "../SQCSim-common/netprotocol.h"
#include "define.h"
@ -11,26 +12,32 @@ public:
~Connector();
int Init();
int Connect(char* srv_addr, std::string name);
int Connect(const char* srv_addr, std::string name);
uint64_t getId() const;
unsigned int getSeed() const;
netprot::Sync getOrigin() const;
//void SendInput();
//int Sync();
SOCKET m_sock_udp = 0,
m_sock_tcp = 0;
sockaddr_in m_srvsockaddr;
// void updateRemotePlayers(std::map<RemotePlayers> rplayers);
std::unordered_map<uint64_t, netprot::PlayerInfo> m_players;
private:
#ifdef _WIN32
WSADATA m_wsaData;
#endif
std::map<Timestamp, netprot::Input> m_inputmanifest;
std::map<uint64_t, netprot::PlayerInfo> m_players;
std::map<uint64_t, netprot::TeamInfo> m_teams;
std::unordered_map<Timestamp, netprot::Input> m_inputmanifest;
std::unordered_map<uint64_t, netprot::TeamInfo> m_teams;
netprot::LoginInfo m_loginfo;
netprot::GameInfo m_gameinfo;
sockaddr_in m_srvsockaddr;
SOCKET m_sock_udp = 0,
m_sock_tcp = 0;
netprot::Sync m_origin;
};
#endif

View File

@ -1,6 +1,8 @@
#ifndef CLI_DEFINE_H__
#define CLI_DEFINE_H__
//#define SFML_STATIC true
#include <iostream>
#include <chrono>
#include <iomanip>
@ -18,16 +20,45 @@
#include <climits>
#endif
#define NETWORK_TEST false
#define SRV_ADDR "127.0.0.1"
#define COUNTDOWN 300
#define BASE_WIDTH 640
#define BASE_HEIGHT 480
#define BULLET_UPDATES_PER_FRAME 20
#define BASE_WIDTH 1280
#define BASE_HEIGHT 720
#define ANIME_PATH_JUMP "./media/textures/AssetOtherPlayer/FinalPNGJumping/"
#define ANIME_PATH_STILL "./media/textures/AssetOtherPlayer/FinalPNGStanding/"
//1 = jump shoot sans anim, 2 = jump shoot avec anim
#define ANIM_PATH_JSHOOT1 "./media/textures/AssetOtherPlayer/FinalPNGJumpingShooting/"
#define ANIM_PATH_JSHOOT2 "./media/textures/AssetOtherPlayer/FinalPNGJumpingShooting/ShootingJump/"
//1 = shoot sans anim, 2 = shoot avec anim
#define ANIM_PATH_SSHOOT1 "./media/textures/AssetOtherPlayer/FinalPNGShooting/"
#define ANIM_PATH_SSHOOT2 "./media/textures/AssetOtherPlayer/FinalPNGShooting/Shooting/"
#define TEXTURE_PATH "./media/textures/"
#define SHADER_PATH "./media/shaders/"
#define AUDIO_PATH "./media/audio/"
#define CHUNK_PATH "./media/chunks/"
#define BOOSTER_TEXTURE_PATH "./media/textures/Booster/"
enum GameState {
MAIN_MENU,
SPLASH,
LOBBY,
OPTIONS,
PLAY,
PAUSE
};
enum Resolution {
HD = 0, // 1280x720 (High Definition)
FHD, // 1920x1080 (Full HD)
QHD, // 2560x1440 (Quad HD)
UHD, // 3840x2160 (Ultra HD)
};
#endif // DEFINE_H__

View File

@ -1 +0,0 @@

File diff suppressed because it is too large Load Diff

View File

@ -2,14 +2,19 @@
#define ENGINE_H__
#include <algorithm>
#include <chrono>
#include <cmath>
#include <unordered_map>
#include <set>
#include "../SQCSim-common/array2d.h"
#include "../SQCSim-common/blockinfo.h"
#include "../SQCSim-common/boostinfo.h"
#include "../SQCSim-common/bullet.h"
#include "../SQCSim-common/chunk.h"
#include "../SQCSim-common/world.h"
#include "../SQCSim-common/transformation.h"
#include "../SQCSim-common/player.h"
#include "../SQCSim-common/booster.h"
#include "define.h"
#include "openglcontext.h"
#include "texture.h"
@ -18,12 +23,17 @@
#include "audio.h"
#include "textureatlas.h"
#include "connector.h"
#include "worldrenderer.h"
#include "renderer.h"
#include "remoteplayer.h"
#include "settings.h"
class Engine : public OpenglContext {
public:
Engine();
virtual ~Engine();
virtual void Init();
virtual void DeInit();
virtual void LoadResource();
@ -36,48 +46,155 @@ public:
virtual void MouseReleaseEvent(const MOUSE_BUTTON& button, int x, int y);
private:
float GetScale() const;
int GetFps(float elapsedTime) const;
int GetCountdown(float elapsedTime);
int GetOptionsChoice();
bool StartMultiplayerGame();
bool LoadTexture(Texture& texture, const std::string& filename, bool useMipmaps = true, bool stopOnError = true);
void ChangeResolution(Resolution resolution);
void InstantDamage();
void SystemNotification(std::string systemLog);
void KillNotification(Player killer, Player killed);
void DisplayNotification(std::string message);
void DisplayCrosshair();
void DisplayPovGun();
void DisplayCurrentItem();
void DisplayHud(int timer);
void DisplayInfo(float elapsedTime, BlockType bloc);
void DrawHud(float elapsedTime, BlockType bloc);
void PrintText(float x, float y, float scale, const std::string& t);
void DisplayInfo(float elapsedTime, BlockType bloc);
Connector m_conn;
Shader m_shader01;
BlockInfo* m_blockinfo[BTYPE_LAST];
TextureAtlas m_textureAtlas = TextureAtlas(BTYPE_LAST);
void DisplaySplashScreen();
World m_world = World();
WorldRenderer m_wrenderer = WorldRenderer();
void DisplayMainMenu();
void DrawButtonBackgrounds(float centerX, float centerY, int iterations);
void DrawMainMenuButtons(float centerX, float centerY);
void DrawSingleMultiButtons(float centerX, float centerY);
Texture m_textureSkybox;
Texture m_textureFont;
Texture m_textureCrosshair;
Texture m_textureGun;
void DisplayLobbyMenu(float elapsedTime);
void SetPlayerUsername(float elapsedTime);
void SetServerAddress(float elapsedTime);
Skybox m_skybox;
Audio m_audio = Audio(AUDIO_PATH "start.wav");
void DisplayPauseMenu(float elapsedTime);
irrklang::ISound* m_powpow;
irrklang::ISound* m_scream;
void DisplayOptionsMenu();
void DisplayAudioMenu(float centerX, float centerY);
void DisplayGraphicsMenu(float centerX, float centerY);
void DisplayGameplayMenu(float centerX, float centerY);
void DrawSliderBackground(float centerX, float centerY, float minVal, float maxVal, float bottomSideValue, float topSideValue);
void DisplayBarPercentValue(float centerX, float centerY, float posX, float posY, float minVal, float maxVal, float value);
void DrawSlider(float centerX, float centerY, float value, float minVal, float maxVal, float bottomSideValue, float topSideValue);
Player m_player = Player(Vector3f(.5f, CHUNK_SIZE_Y + 1.8f, .5f));
void PrintText(float x, float y, const std::string& t, float charSizeMultiplier = 1.0f);
void ProcessNotificationQueue();
char SimulateKeyboard(unsigned char key);
void HandlePlayerInput(float elapsedTime);
Audio m_audio = Audio(AUDIO_PATH "music01.wav", AUDIO_PATH "menumusic01.wav");
irrklang::ISound* m_powpow, * m_scream;
irrklang::ISound* m_whoosh[MAX_BULLETS];
Bullet* m_bullets[MAX_BULLETS];
//Menu
Vector3f m_otherplayerpos = Vector3f(999, 999, 999);
World m_world = World();
Player m_player = Player(Vector3f(.5f, CHUNK_SIZE_Y + 1.8f, .5f));
Renderer m_renderer = Renderer();
BlockInfo* m_blockinfo[BTYPE_LAST];
BoostInfo* m_boostinfo[BTYPE_BOOST_LAST];
GameState m_gamestate = GameState::SPLASH;
Shader m_shader01;
Skybox m_skybox;
TextureAtlas m_textureAtlas = TextureAtlas(BTYPE_LAST);
TextureAtlas m_animeAtlas = TextureAtlas(TYPE_LAST + POS_LAST);
TextureAtlas::TextureIndex texBoostHeal;
Texture m_textureCrosshair;
Texture m_textureFont;
Texture m_textureGun;
Texture m_texturePovGun;
Texture m_textureSkybox;
Texture m_textureLobbyMenu;
Texture m_textureMainMenu;
Texture m_textureOptionsMenu;
Texture m_texturePauseMenu;
Texture m_textureSplashScreen;
Texture m_textureHd;
Texture m_textureFhd;
Texture m_textureQhd;
Texture m_textureUhd;
Texture m_textureLobbyServer;
Texture m_textureLobbyIdentify;
Texture m_textureCheck;
Texture m_textureChecked;
Texture m_texturePauseResume;
Texture m_texturePauseMainMenu;
Texture m_textureOptAudio;
Texture m_textureOptBack;
Texture m_textureOptGameplay;
Texture m_textureOptGraphics;
Texture m_textureOptMain;
Texture m_textureOptMusic;
Texture m_textureOptOptions;
Texture m_textureOptResolution;
Texture m_textureOptSensitivity;
Texture m_textureOptSfx;
Texture m_textureMenuBack;
Texture m_textureMenuMulti;
Texture m_textureMenuOptions;
Texture m_textureMenuPlay;
Texture m_textureMenuQuit;
Texture m_textureMenuSingle;
Texture m_textureMenuTitle;
Settings m_options = Settings(m_audio);
Resolution m_resolution = HD;
float m_splashTime = 2.0f;
float m_scale;
float m_time = 0;
float m_titleX = 0;
float m_titleY = 0;
int m_renderCount = 0;
int m_countdown = COUNTDOWN;
int m_nbReductionChunk = 4;
int m_timerReductionChunk = 30;
float m_mainvolume;
float m_musicvolume;
float m_sfxvolume;
float m_sensitivity;
int m_selectedOption = 0;
bool m_selectedOptAudioMainBar = false;
bool m_selectedOptAudioMusicBar = false;
bool m_selectedOptAudioSfxBar = false;
bool m_selectedGameplaySensitivityBar = false;
bool m_damage = false;
bool m_wireframe = false;
bool m_isSkybox = true;
@ -85,20 +202,67 @@ private:
bool m_flash = true;
bool m_displayCrosshair = true;
bool m_displayHud = true;
bool m_displayInfo = false;
bool m_displayInfo = true;
bool m_resetcountdown = false;
bool m_soloMultiChoiceMade = false;
bool m_stopcountdown = false;
bool m_selectedPlayOptions = false;
bool m_selectedOptions = false;
bool m_selectedQuit = false;
std::string m_currentInputString;
std::string m_username;
std::string m_serverAddr;
char m_inputChar = 0;
bool m_invalidChar = false;
bool m_charChanged = false;
bool m_settingUsername = false;
bool m_settingServer = false;
bool m_selectedSinglePlayer = false;
bool m_selectedMultiPlayer = false;
bool m_singleReady = false;
bool m_multiReady = false;
bool m_key1 = false;
bool m_key2 = false;
bool m_keyK = false;
bool m_keyL = false;
bool m_keyW = false;
bool m_keyA = false;
bool m_keyS = false;
bool m_keyD = false;
bool m_keyEnter = false;
bool m_keySpace = false;
bool m_keyShift = false;
bool m_keyBackspace = false;
bool m_mouseL = false;
bool m_mouseR = false;
bool m_mouseC = false;
bool m_mouseWU = false;
bool m_mouseWD = false;
float m_mousemx = 0;
float m_mousemy = 0;
bool m_networkgame = false;
Connector m_conn;
std::deque<netprot::ChunkMod*> m_chunkmod_manifest;
std::chrono::high_resolution_clock::time_point m_startTime;
std::unordered_map<uint64_t, Player*> m_players;
std::set<uint64_t> m_deadplayers;
netprot::Buffer m_buf, m_bufout;
netprot::ChunkMod* m_chunkmod = nullptr;
std::unordered_map<uint64_t, Booster*> m_boosters;
std::set<uint64_t> m_boost_manifest;
std::unordered_map<uint64_t, netprot::Sync> m_syncs;
std::string m_messageNotification = "";
};
#endif // ENGINE_H__

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

View File

@ -0,0 +1,98 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>SFML - Simple and Fast Multimedia Library</title>
<meta http-equiv="Content-Type" content="text/html;"/>
<meta charset="utf-8"/>
<!--<link rel='stylesheet' type='text/css' href="https://fonts.googleapis.com/css?family=Ubuntu:400,700,400italic"/>-->
<link rel="stylesheet" type="text/css" href="doxygen.css" title="default" media="screen,print" />
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
</head>
<body>
<div id="banner-container">
<div id="banner">
<span id="sfml">SFML 2.5.1</span>
</div>
</div>
<div id="content">
<!-- Generated by Doxygen 1.8.14 -->
<div id="navrow1" class="tabs">
<ul class="tablist">
<li><a href="index.html"><span>Main&#160;Page</span></a></li>
<li><a href="pages.html"><span>Related&#160;Pages</span></a></li>
<li><a href="modules.html"><span>Modules</span></a></li>
<li><a href="namespaces.html"><span>Namespaces</span></a></li>
<li><a href="annotated.html"><span>Classes</span></a></li>
<li class="current"><a href="files.html"><span>Files</span></a></li>
</ul>
</div>
<div id="navrow2" class="tabs2">
<ul class="tablist">
<li><a href="files.html"><span>File&#160;List</span></a></li>
<li><a href="globals.html"><span>File&#160;Members</span></a></li>
</ul>
</div>
<div id="nav-path" class="navpath">
<ul>
<li class="navelem"><a class="el" href="dir_d44c64559bbebec7f509842c48db8b23.html">include</a></li><li class="navelem"><a class="el" href="dir_c0a853e81d6f1c1f0a3eb7a27dc24256.html">SFML</a></li> </ul>
</div>
</div><!-- top -->
<div class="header">
<div class="summary">
<a href="#define-members">Macros</a> </div>
<div class="headertitle">
<div class="title">GpuPreference.hpp File Reference</div> </div>
</div><!--header-->
<div class="contents">
<p>Headers.
<a href="#details">More...</a></p>
<div class="textblock"><code>#include &lt;SFML/Config.hpp&gt;</code><br />
</div>
<p><a href="GpuPreference_8hpp_source.html">Go to the source code of this file.</a></p>
<table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
Macros</h2></td></tr>
<tr class="memitem:ab0233c2d867cbd561036ed2440a4fec0"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="GpuPreference_8hpp.html#ab0233c2d867cbd561036ed2440a4fec0">SFML_DEFINE_DISCRETE_GPU_PREFERENCE</a></td></tr>
<tr class="memdesc:ab0233c2d867cbd561036ed2440a4fec0"><td class="mdescLeft">&#160;</td><td class="mdescRight">A macro to encourage usage of the discrete GPU. <a href="#ab0233c2d867cbd561036ed2440a4fec0">More...</a><br /></td></tr>
<tr class="separator:ab0233c2d867cbd561036ed2440a4fec0"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<div class="textblock"><p>Headers. </p>
<p>File containing SFML_DEFINE_DISCRETE_GPU_PREFERENCE </p>
<p class="definition">Definition in file <a class="el" href="GpuPreference_8hpp_source.html">GpuPreference.hpp</a>.</p>
</div><h2 class="groupheader">Macro Definition Documentation</h2>
<a id="ab0233c2d867cbd561036ed2440a4fec0"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ab0233c2d867cbd561036ed2440a4fec0">&#9670;&nbsp;</a></span>SFML_DEFINE_DISCRETE_GPU_PREFERENCE</h2>
<div class="memitem">
<div class="memproto">
<table class="memname">
<tr>
<td class="memname">#define SFML_DEFINE_DISCRETE_GPU_PREFERENCE</td>
</tr>
</table>
</div><div class="memdoc">
<p>A macro to encourage usage of the discrete GPU. </p>
<p>In order to inform the Nvidia/AMD driver that an SFML application could benefit from using the more powerful discrete GPU, special symbols have to be publicly exported from the final executable.</p>
<p>SFML defines a helper macro to easily do this.</p>
<p>Place SFML_DEFINE_DISCRETE_GPU_PREFERENCE in the global scope of a source file that will be linked into the final executable. Typically it is best to place it where the main function is also defined. </p>
<p class="definition">Definition at line <a class="el" href="GpuPreference_8hpp_source.html#l00069">69</a> of file <a class="el" href="GpuPreference_8hpp_source.html">GpuPreference.hpp</a>.</p>
</div>
</div>
</div><!-- contents -->
</div>
<div id="footer-container">
<div id="footer">
SFML is licensed under the terms and conditions of the <a href="https://www.sfml-dev.org/license.php">zlib/png license</a>.<br>
Copyright &copy; Laurent Gomila &nbsp;::&nbsp;
Documentation generated by <a href="http://www.doxygen.org/" title="doxygen website">doxygen</a> &nbsp;::&nbsp;
</div>
</div>
</body>
</html>

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

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