author | unc0rr |
Mon, 18 Jun 2012 23:45:21 +0400 | |
changeset 7262 | 33e703cc7a7f |
parent 7202 | 2d78dc517c91 |
child 7231 | f484455dd055 |
child 7403 | e8d0b21efa82 |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
6700 | 3 |
* Copyright (c) 2004-2012 Andrey Korotaev <unC0Rr@gmail.com> |
4 | 4 |
* |
183 | 5 |
* This program is free software; you can redistribute it and/or modify |
6 |
* it under the terms of the GNU General Public License as published by |
|
7 |
* the Free Software Foundation; version 2 of the License |
|
4 | 8 |
* |
183 | 9 |
* This program is distributed in the hope that it will be useful, |
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
4 | 13 |
* |
183 | 14 |
* You should have received a copy of the GNU General Public License |
15 |
* along with this program; if not, write to the Free Software |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
|
4 | 17 |
*) |
18 |
||
2630 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
6954
a61458a81480
changed uKeys to uInputHandler to better reflect its function
Xeli
parents:
6942
diff
changeset
|
21 |
unit uInputHandler; |
4 | 22 |
interface |
4363 | 23 |
uses SDLh, uTypes; |
4 | 24 |
|
3038 | 25 |
procedure initModule; |
26 |
procedure freeModule; |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2714
diff
changeset
|
27 |
|
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
28 |
function KeyNameToCode(name: shortstring; Modifier: shortstring = ''): LongInt; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
29 |
procedure MaskModifier(var code: LongInt; modifier: LongWord); |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
30 |
procedure MaskModifier(Modifier: shortstring; var code: LongInt); |
6917 | 31 |
procedure ProcessMouse(event: TSDL_MouseButtonEvent; ButtonDown: boolean); |
6992 | 32 |
procedure ProcessKey(event: TSDL_KeyboardEvent); inline; |
33 |
procedure ProcessKey(code: LongInt; KeyDown: boolean); |
|
34 |
||
4 | 35 |
procedure ResetKbd; |
948 | 36 |
procedure FreezeEnterKey; |
4 | 37 |
procedure InitKbdKeyTable; |
38 |
||
167 | 39 |
procedure SetBinds(var binds: TBinds); |
40 |
procedure SetDefaultBinds; |
|
41 |
||
2428 | 42 |
procedure ControllerInit; |
43 |
procedure ControllerAxisEvent(joy, axis: Byte; value: Integer); |
|
44 |
procedure ControllerHatEvent(joy, hat, value: Byte); |
|
45 |
procedure ControllerButtonEvent(joy, button: Byte; pressed: Boolean); |
|
46 |
||
4 | 47 |
implementation |
4403 | 48 |
uses uConsole, uCommands, uMisc, uVariables, uConsts, uUtils, uDebug; |
167 | 49 |
|
7193 | 50 |
const |
51 |
LSHIFT = $0200; |
|
52 |
RSHIFT = $0400; |
|
53 |
LALT = $0800; |
|
54 |
RALT = $1000; |
|
55 |
LCTRL = $2000; |
|
56 |
RCTRL = $4000; |
|
57 |
||
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
58 |
var tkbd: array[0..cKbdMaxIndex] of boolean; |
6942 | 59 |
quitKeyCode: Byte; |
4 | 60 |
KeyNames: array [0..cKeyMaxIndex] of string[15]; |
6982 | 61 |
CurrentBinds: TBinds; |
3697 | 62 |
|
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
63 |
function KeyNameToCode(name: shortstring; Modifier: shortstring): LongInt; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
64 |
var code: LongInt; |
2678
334016e8d895
injection of custom code in SDL for iPhone in order to implement our frontend
koda
parents:
2674
diff
changeset
|
65 |
begin |
6917 | 66 |
name:= LowerCase(name); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
67 |
code:= cKeyMaxIndex; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
68 |
while (code > 0) and (KeyNames[code] <> name) do dec(code); |
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
69 |
|
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
70 |
MaskModifier(Modifier, code); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
71 |
KeyNameToCode:= code; |
2678
334016e8d895
injection of custom code in SDL for iPhone in order to implement our frontend
koda
parents:
2674
diff
changeset
|
72 |
end; |
334016e8d895
injection of custom code in SDL for iPhone in order to implement our frontend
koda
parents:
2674
diff
changeset
|
73 |
|
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
74 |
procedure MaskModifier(var code: LongInt; Modifier: LongWord); |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
75 |
begin |
7193 | 76 |
if(Modifier and KMOD_LSHIFT) <> 0 then code:= code or LSHIFT; |
77 |
if(Modifier and KMOD_RSHIFT) <> 0 then code:= code or LSHIFT; |
|
78 |
if(Modifier and KMOD_LALT) <> 0 then code:= code or LALT; |
|
79 |
if(Modifier and KMOD_RALT) <> 0 then code:= code or LALT; |
|
80 |
if(Modifier and KMOD_LCTRL) <> 0 then code:= code or LCTRL; |
|
81 |
if(Modifier and KMOD_RCTRL) <> 0 then code:= code or LCTRL; |
|
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
82 |
end; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
83 |
|
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
84 |
procedure MaskModifier(Modifier: shortstring; var code: LongInt); |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
85 |
var mod_ : shortstring; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
86 |
ModifierCount, i: LongInt; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
87 |
begin |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
88 |
if Modifier = '' then exit; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
89 |
ModifierCount:= 0; |
7202 | 90 |
|
91 |
for i:= 1 to Length(Modifier) do |
|
92 |
if(Modifier[i] = ':') then inc(ModifierCount); |
|
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
93 |
|
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
94 |
SplitByChar(Modifier, mod_, ':');//remove the first mod: part |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
95 |
Modifier:= mod_; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
96 |
for i:= 0 to ModifierCount do |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
97 |
begin |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
98 |
mod_:= ''; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
99 |
SplitByChar(Modifier, mod_, ':'); |
7193 | 100 |
if (Modifier = 'lshift') then code:= code or LSHIFT; |
101 |
if (Modifier = 'rshift') then code:= code or RSHIFT; |
|
102 |
if (Modifier = 'lalt') then code:= code or LALT; |
|
103 |
if (Modifier = 'ralt') then code:= code or RALT; |
|
104 |
if (Modifier = 'lctrl') or (mod_ = 'lmeta') then code:= code or LCTRL; |
|
105 |
if (Modifier = 'rctrl') or (mod_ = 'rmeta') then code:= code or RCTRL; |
|
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
106 |
Modifier:= mod_; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
107 |
end; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
108 |
end; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
109 |
|
6917 | 110 |
procedure ProcessKey(code: LongInt; KeyDown: boolean); |
111 |
var |
|
112 |
Trusted: boolean; |
|
113 |
s : string; |
|
114 |
begin |
|
7141
ea6ad9a97fca
change the array which represents the keyboard state to be a boolean array rather than byte array
Xeli
parents:
7140
diff
changeset
|
115 |
if not(tkbd[code] xor KeyDown) then exit; |
ea6ad9a97fca
change the array which represents the keyboard state to be a boolean array rather than byte array
Xeli
parents:
7140
diff
changeset
|
116 |
tkbd[code]:= KeyDown; |
7140
29948153fda2
Don't allow for multiple key up(or down) events, it will ignore the excess events
Xeli
parents:
7118
diff
changeset
|
117 |
|
6917 | 118 |
hideAmmoMenu:= false; |
119 |
Trusted:= (CurrentTeam <> nil) |
|
120 |
and (not CurrentTeam^.ExtDriven) |
|
121 |
and (CurrentHedgehog^.BotLevel = 0); |
|
122 |
||
6942 | 123 |
// ctrl/cmd + q to close engine and frontend |
124 |
if(KeyDown and (code = quitKeyCode)) then |
|
125 |
begin |
|
126 |
{$IFDEF DARWIN} |
|
7141
ea6ad9a97fca
change the array which represents the keyboard state to be a boolean array rather than byte array
Xeli
parents:
7140
diff
changeset
|
127 |
if tkbd[KeyNameToCode('left_meta')] or tkbd[KeyNameToCode('right_meta')] then |
6942 | 128 |
{$ELSE} |
7141
ea6ad9a97fca
change the array which represents the keyboard state to be a boolean array rather than byte array
Xeli
parents:
7140
diff
changeset
|
129 |
if tkbd[KeyNameToCode('left_ctrl')] or tkbd[KeyNameToCode('right_ctrl')] then |
6942 | 130 |
{$ENDIF} |
131 |
ParseCommand('halt', true); |
|
132 |
end; |
|
133 |
||
6917 | 134 |
if CurrentBinds[code][0] <> #0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
135 |
begin |
7141
ea6ad9a97fca
change the array which represents the keyboard state to be a boolean array rather than byte array
Xeli
parents:
7140
diff
changeset
|
136 |
if (code > 3) and KeyDown and not ((CurrentBinds[code] = 'put') or (CurrentBinds[code] = 'ammomenu') or (CurrentBinds[code] = '+cur_u') or (CurrentBinds[code] = '+cur_d') or (CurrentBinds[code] = '+cur_l') or (CurrentBinds[code] = '+cur_r')) then hideAmmoMenu:= true; |
7118 | 137 |
|
7140
29948153fda2
Don't allow for multiple key up(or down) events, it will ignore the excess events
Xeli
parents:
7118
diff
changeset
|
138 |
if KeyDown then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
139 |
begin |
6917 | 140 |
ParseCommand(CurrentBinds[code], Trusted); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
141 |
if (CurrentTeam <> nil) and (not CurrentTeam^.ExtDriven) and (ReadyTimeLeft > 1) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
142 |
ParseCommand('gencmd R', true) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
143 |
end |
7140
29948153fda2
Don't allow for multiple key up(or down) events, it will ignore the excess events
Xeli
parents:
7118
diff
changeset
|
144 |
else if (CurrentBinds[code][1] = '+') then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
145 |
begin |
6917 | 146 |
s:= CurrentBinds[code]; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
147 |
s[1]:= '-'; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
148 |
ParseCommand(s, Trusted); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
149 |
if (CurrentTeam <> nil) and (not CurrentTeam^.ExtDriven) and (ReadyTimeLeft > 1) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
150 |
ParseCommand('gencmd R', true) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
151 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
152 |
end |
6917 | 153 |
end; |
154 |
||
6992 | 155 |
procedure ProcessKey(event: TSDL_KeyboardEvent); inline; |
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
156 |
var code: LongInt; |
6917 | 157 |
begin |
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
158 |
code:= event.keysym.sym; |
7199 | 159 |
//MaskModifier(code, event.keysym.modifier); |
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
160 |
ProcessKey(code, event.type_ = SDL_KEYDOWN); |
6917 | 161 |
end; |
162 |
||
163 |
procedure ProcessMouse(event: TSDL_MouseButtonEvent; ButtonDown: boolean); |
|
164 |
begin |
|
165 |
case event.button of |
|
166 |
SDL_BUTTON_LEFT: |
|
167 |
ProcessKey(KeyNameToCode('mousel'), ButtonDown); |
|
168 |
SDL_BUTTON_MIDDLE: |
|
169 |
ProcessKey(KeyNameToCode('mousem'), ButtonDown); |
|
170 |
SDL_BUTTON_RIGHT: |
|
171 |
ProcessKey(KeyNameToCode('mouser'), ButtonDown); |
|
172 |
SDL_BUTTON_WHEELDOWN: |
|
173 |
ProcessKey(KeyNameToCode('wheeldown'), ButtonDown); |
|
174 |
SDL_BUTTON_WHEELUP: |
|
175 |
ProcessKey(KeyNameToCode('wheelup'), ButtonDown); |
|
176 |
end; |
|
4 | 177 |
end; |
178 |
||
179 |
procedure ResetKbd; |
|
7117
7df6386f7090
reimplemented ResetKbd and calling it when exiting gsChat status, this restores behavior from.17: You can now walk -> press t/chat -> type some stuff while still walking -> exit gsChat and stop walking at that moment
Xeli
parents:
7106
diff
changeset
|
180 |
var t: LongInt; |
4 | 181 |
begin |
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
182 |
for t:= 0 to cKbdMaxIndex do |
7141
ea6ad9a97fca
change the array which represents the keyboard state to be a boolean array rather than byte array
Xeli
parents:
7140
diff
changeset
|
183 |
if tkbd[t] then |
7117
7df6386f7090
reimplemented ResetKbd and calling it when exiting gsChat status, this restores behavior from.17: You can now walk -> press t/chat -> type some stuff while still walking -> exit gsChat and stop walking at that moment
Xeli
parents:
7106
diff
changeset
|
184 |
ProcessKey(t, False); |
4 | 185 |
end; |
186 |
||
187 |
procedure InitKbdKeyTable; |
|
2428 | 188 |
var i, j, k, t: LongInt; |
4 | 189 |
s: string[15]; |
190 |
begin |
|
6917 | 191 |
//TODO in sdl13 this overrides some values (A and B) change indices to some other values at the back perhaps? |
6909 | 192 |
KeyNames[1]:= 'mousel'; |
193 |
KeyNames[2]:= 'mousem'; |
|
194 |
KeyNames[3]:= 'mouser'; |
|
195 |
KeyNames[4]:= 'wheelup'; |
|
196 |
KeyNames[5]:= 'wheeldown'; |
|
197 |
||
198 |
for i:= 6 to cKeyMaxIndex do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
199 |
begin |
4046
cfdbddc4b385
making indentation consistent (noticed while debugging)
nemo
parents:
3971
diff
changeset
|
200 |
s:= shortstring(sdl_getkeyname(i)); |
7106 | 201 |
//WriteLnToConsole(IntToStr(i) + ': ' + s + ' ' + IntToStr(cKeyMaxIndex)); |
4046
cfdbddc4b385
making indentation consistent (noticed while debugging)
nemo
parents:
3971
diff
changeset
|
202 |
if s = 'unknown key' then KeyNames[i]:= '' |
cfdbddc4b385
making indentation consistent (noticed while debugging)
nemo
parents:
3971
diff
changeset
|
203 |
else |
cfdbddc4b385
making indentation consistent (noticed while debugging)
nemo
parents:
3971
diff
changeset
|
204 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
205 |
for t:= 1 to Length(s) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
206 |
if s[t] = ' ' then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
207 |
s[t]:= '_'; |
6917 | 208 |
KeyNames[i]:= LowerCase(s) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
209 |
end; |
4046
cfdbddc4b385
making indentation consistent (noticed while debugging)
nemo
parents:
3971
diff
changeset
|
210 |
end; |
2613 | 211 |
|
7071 | 212 |
quitKeyCode:= KeyNameToCode(_S'q'); |
167 | 213 |
|
6909 | 214 |
// get the size of keyboard array |
215 |
SDL_GetKeyState(@k); |
|
216 |
||
2428 | 217 |
// Controller(s) |
218 |
for j:= 0 to Pred(ControllerNumControllers) do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
219 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
220 |
for i:= 0 to Pred(ControllerNumAxes[j]) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
221 |
begin |
4374 | 222 |
keynames[k + 0]:= 'j' + IntToStr(j) + 'a' + IntToStr(i) + 'u'; |
223 |
keynames[k + 1]:= 'j' + IntToStr(j) + 'a' + IntToStr(i) + 'd'; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
224 |
inc(k, 2); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
225 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
226 |
for i:= 0 to Pred(ControllerNumHats[j]) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
227 |
begin |
4374 | 228 |
keynames[k + 0]:= 'j' + IntToStr(j) + 'h' + IntToStr(i) + 'u'; |
229 |
keynames[k + 1]:= 'j' + IntToStr(j) + 'h' + IntToStr(i) + 'r'; |
|
230 |
keynames[k + 2]:= 'j' + IntToStr(j) + 'h' + IntToStr(i) + 'd'; |
|
231 |
keynames[k + 3]:= 'j' + IntToStr(j) + 'h' + IntToStr(i) + 'l'; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
232 |
inc(k, 4); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
233 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
234 |
for i:= 0 to Pred(ControllerNumButtons[j]) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
235 |
begin |
4374 | 236 |
keynames[k]:= 'j' + IntToStr(j) + 'b' + IntToStr(i); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
237 |
inc(k, 1); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
238 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
239 |
end; |
2581 | 240 |
|
6917 | 241 |
DefaultBinds[KeyNameToCode('escape')]:= 'quit'; |
242 |
DefaultBinds[KeyNameToCode('grave')]:= 'history'; |
|
243 |
DefaultBinds[KeyNameToCode('delete')]:= 'rotmask'; |
|
2379 | 244 |
|
2606
ed687a8d081f
updated build files for macosx and optimization system
koda
parents:
2599
diff
changeset
|
245 |
//numpad |
ed687a8d081f
updated build files for macosx and optimization system
koda
parents:
2599
diff
changeset
|
246 |
//DefaultBinds[265]:= '+volup'; |
ed687a8d081f
updated build files for macosx and optimization system
koda
parents:
2599
diff
changeset
|
247 |
//DefaultBinds[256]:= '+voldown'; |
ed687a8d081f
updated build files for macosx and optimization system
koda
parents:
2599
diff
changeset
|
248 |
|
7071 | 249 |
DefaultBinds[KeyNameToCode(_S'0')]:= '+volup'; |
250 |
DefaultBinds[KeyNameToCode(_S'9')]:= '+voldown'; |
|
251 |
DefaultBinds[KeyNameToCode(_S'c')]:= 'capture'; |
|
252 |
DefaultBinds[KeyNameToCode(_S'h')]:= 'findhh'; |
|
253 |
DefaultBinds[KeyNameToCode(_S'p')]:= 'pause'; |
|
254 |
DefaultBinds[KeyNameToCode(_S's')]:= '+speedup'; |
|
255 |
DefaultBinds[KeyNameToCode(_S't')]:= 'chat'; |
|
256 |
DefaultBinds[KeyNameToCode(_S'y')]:= 'confirm'; |
|
1051
dfdd5dfe97d4
Enable fullscreen switching back, now it's bound on F12
unc0rr
parents:
1022
diff
changeset
|
257 |
|
6909 | 258 |
DefaultBinds[KeyNameToCode('mousem')]:= 'zoomreset'; |
7106 | 259 |
DefaultBinds[KeyNameToCode('wheelup')]:= 'zoomin'; |
260 |
DefaultBinds[KeyNameToCode('wheeldown')]:= 'zoomout'; |
|
2407
9f413bd5150e
- Fix mouse cursor bugs in net game (still has a bug near water)
unc0rr
parents:
2379
diff
changeset
|
261 |
|
6909 | 262 |
DefaultBinds[KeyNameToCode('f12')]:= 'fullscr'; |
1051
dfdd5dfe97d4
Enable fullscreen switching back, now it's bound on F12
unc0rr
parents:
1022
diff
changeset
|
263 |
|
2786 | 264 |
|
6917 | 265 |
DefaultBinds[KeyNameToCode('mousel')]:= '/put'; |
266 |
DefaultBinds[KeyNameToCode('mouser')]:= 'ammomenu'; |
|
267 |
DefaultBinds[KeyNameToCode('backspace')]:= 'hjump'; |
|
268 |
DefaultBinds[KeyNameToCode('tab')]:= 'switch'; |
|
269 |
DefaultBinds[KeyNameToCode('return')]:= 'ljump'; |
|
270 |
DefaultBinds[KeyNameToCode('space')]:= '+attack'; |
|
6909 | 271 |
DefaultBinds[KeyNameToCode('up')]:= '+up'; |
272 |
DefaultBinds[KeyNameToCode('down')]:= '+down'; |
|
273 |
DefaultBinds[KeyNameToCode('left')]:= '+left'; |
|
274 |
DefaultBinds[KeyNameToCode('right')]:= '+right'; |
|
275 |
DefaultBinds[KeyNameToCode('left_shift')]:= '+precise'; |
|
2754
ad4f81fbfb76
touchinput works, invisible buttons added and initial support for chat
koda
parents:
2716
diff
changeset
|
276 |
|
7088
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
277 |
|
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
278 |
DefaultBinds[KeyNameToCode('j0a0u')]:= '+left'; |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
279 |
DefaultBinds[KeyNameToCode('j0a0d')]:= '+right'; |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
280 |
DefaultBinds[KeyNameToCode('j0a1u')]:= '+up'; |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
281 |
DefaultBinds[KeyNameToCode('j0a1d')]:= '+down'; |
6909 | 282 |
for i:= 1 to 10 do DefaultBinds[KeyNameToCode('f'+IntToStr(i))]:= 'slot '+IntToStr(i); |
283 |
for i:= 1 to 5 do DefaultBinds[KeyNameToCode(IntToStr(i))]:= 'timer '+IntToStr(i); |
|
4131
e89d11f6361c
add F1-F10 to the default binds to fix weapon selection in trainings/missions and such
nemo
parents:
4046
diff
changeset
|
284 |
|
2754
ad4f81fbfb76
touchinput works, invisible buttons added and initial support for chat
koda
parents:
2716
diff
changeset
|
285 |
SetDefaultBinds(); |
4 | 286 |
end; |
287 |
||
167 | 288 |
procedure SetBinds(var binds: TBinds); |
7184
211ab9e2cb15
only reset those keys which actually change their bindings
Xeli
parents:
7151
diff
changeset
|
289 |
{$IFNDEF MOBILE} |
211ab9e2cb15
only reset those keys which actually change their bindings
Xeli
parents:
7151
diff
changeset
|
290 |
var |
211ab9e2cb15
only reset those keys which actually change their bindings
Xeli
parents:
7151
diff
changeset
|
291 |
t: LongInt; |
211ab9e2cb15
only reset those keys which actually change their bindings
Xeli
parents:
7151
diff
changeset
|
292 |
{$ENDIF} |
167 | 293 |
begin |
6654
120e95c10532
use the way actions are initiated the same way as koda implemented with PascalExports, using boolean values such as upKey and enterKey, this prevents the user from being able to control the AI
Xeli
parents:
6580
diff
changeset
|
294 |
{$IFDEF MOBILE} |
3971 | 295 |
binds:= binds; // avoid hint |
3663
8c28abf427f5
reduce the number of keywords used and switch to BMP format for screenshots
koda
parents:
3651
diff
changeset
|
296 |
CurrentBinds:= DefaultBinds; |
8c28abf427f5
reduce the number of keywords used and switch to BMP format for screenshots
koda
parents:
3651
diff
changeset
|
297 |
{$ELSE} |
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
298 |
for t:= 0 to cKbdMaxIndex do |
7184
211ab9e2cb15
only reset those keys which actually change their bindings
Xeli
parents:
7151
diff
changeset
|
299 |
if (CurrentBinds[t] <> binds[t]) and tkbd[t] then |
211ab9e2cb15
only reset those keys which actually change their bindings
Xeli
parents:
7151
diff
changeset
|
300 |
ProcessKey(t, False); |
211ab9e2cb15
only reset those keys which actually change their bindings
Xeli
parents:
7151
diff
changeset
|
301 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
302 |
CurrentBinds:= binds; |
3663
8c28abf427f5
reduce the number of keywords used and switch to BMP format for screenshots
koda
parents:
3651
diff
changeset
|
303 |
{$ENDIF} |
167 | 304 |
end; |
305 |
||
306 |
procedure SetDefaultBinds; |
|
307 |
begin |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
308 |
CurrentBinds:= DefaultBinds; |
167 | 309 |
end; |
310 |
||
948 | 311 |
procedure FreezeEnterKey; |
312 |
begin |
|
7141
ea6ad9a97fca
change the array which represents the keyboard state to be a boolean array rather than byte array
Xeli
parents:
7140
diff
changeset
|
313 |
tkbd[3]:= True; |
ea6ad9a97fca
change the array which represents the keyboard state to be a boolean array rather than byte array
Xeli
parents:
7140
diff
changeset
|
314 |
tkbd[13]:= True; |
ea6ad9a97fca
change the array which represents the keyboard state to be a boolean array rather than byte array
Xeli
parents:
7140
diff
changeset
|
315 |
tkbd[27]:= True; |
ea6ad9a97fca
change the array which represents the keyboard state to be a boolean array rather than byte array
Xeli
parents:
7140
diff
changeset
|
316 |
tkbd[271]:= True; |
948 | 317 |
end; |
167 | 318 |
|
2591
c6597b65caea
other controls implementation + sdlh revisited (once again)
koda
parents:
2590
diff
changeset
|
319 |
var Controller: array [0..5] of PSDL_Joystick; |
3697 | 320 |
|
2428 | 321 |
procedure ControllerInit; |
322 |
var i, j: Integer; |
|
323 |
begin |
|
3663
8c28abf427f5
reduce the number of keywords used and switch to BMP format for screenshots
koda
parents:
3651
diff
changeset
|
324 |
ControllerEnabled:= 0; |
7088
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
325 |
{$IFDEF IPHONE} |
3663
8c28abf427f5
reduce the number of keywords used and switch to BMP format for screenshots
koda
parents:
3651
diff
changeset
|
326 |
exit; // joystick subsystem disabled on iPhone |
3513
f589230fa21b
now it's possible to select the scheme file in the ifrontendfix a type about loading an image (iphone file system IS case senstive)
koda
parents:
3493
diff
changeset
|
327 |
{$ENDIF} |
2674
2fce032f2f95
lupdate + Palewolf's updated spanish translation + other patches of mine
koda
parents:
2671
diff
changeset
|
328 |
|
3663
8c28abf427f5
reduce the number of keywords used and switch to BMP format for screenshots
koda
parents:
3651
diff
changeset
|
329 |
SDL_InitSubSystem(SDL_INIT_JOYSTICK); |
2674
2fce032f2f95
lupdate + Palewolf's updated spanish translation + other patches of mine
koda
parents:
2671
diff
changeset
|
330 |
ControllerNumControllers:= SDL_NumJoysticks(); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
331 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
332 |
if ControllerNumControllers > 6 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
333 |
ControllerNumControllers:= 6; |
2428 | 334 |
|
4374 | 335 |
WriteLnToConsole('Number of game controllers: ' + IntToStr(ControllerNumControllers)); |
2428 | 336 |
|
337 |
if ControllerNumControllers > 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
338 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
339 |
for j:= 0 to pred(ControllerNumControllers) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
340 |
begin |
7151 | 341 |
WriteLnToConsole('Using game controller: ' + shortstring(SDL_JoystickName(j))); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
342 |
Controller[j]:= SDL_JoystickOpen(j); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
343 |
if Controller[j] = nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
344 |
WriteLnToConsole('* Failed to open game controller!') |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
345 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
346 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
347 |
ControllerNumAxes[j]:= SDL_JoystickNumAxes(Controller[j]); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
348 |
//ControllerNumBalls[j]:= SDL_JoystickNumBalls(Controller[j]); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
349 |
ControllerNumHats[j]:= SDL_JoystickNumHats(Controller[j]); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
350 |
ControllerNumButtons[j]:= SDL_JoystickNumButtons(Controller[j]); |
4374 | 351 |
WriteLnToConsole('* Number of axes: ' + IntToStr(ControllerNumAxes[j])); |
352 |
//WriteLnToConsole('* Number of balls: ' + IntToStr(ControllerNumBalls[j])); |
|
353 |
WriteLnToConsole('* Number of hats: ' + IntToStr(ControllerNumHats[j])); |
|
354 |
WriteLnToConsole('* Number of buttons: ' + IntToStr(ControllerNumButtons[j])); |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
355 |
ControllerEnabled:= 1; |
3697 | 356 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
357 |
if ControllerNumAxes[j] > 20 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
358 |
ControllerNumAxes[j]:= 20; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
359 |
//if ControllerNumBalls[j] > 20 then ControllerNumBalls[j]:= 20; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
360 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
361 |
if ControllerNumHats[j] > 20 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
362 |
ControllerNumHats[j]:= 20; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
363 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
364 |
if ControllerNumButtons[j] > 20 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6497
diff
changeset
|
365 |
ControllerNumButtons[j]:= 20; |
3697 | 366 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
367 |
// reset all buttons/axes |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
368 |
for i:= 0 to pred(ControllerNumAxes[j]) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
369 |
ControllerAxes[j][i]:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
370 |
(*for i:= 0 to pred(ControllerNumBalls[j]) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
371 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
372 |
ControllerBalls[j][i][0]:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
373 |
ControllerBalls[j][i][1]:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
374 |
end;*) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
375 |
for i:= 0 to pred(ControllerNumHats[j]) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
376 |
ControllerHats[j][i]:= SDL_HAT_CENTERED; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
377 |
for i:= 0 to pred(ControllerNumButtons[j]) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
378 |
ControllerButtons[j][i]:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
379 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
380 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
381 |
// enable event generation/controller updating |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
382 |
SDL_JoystickEventState(1); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
383 |
end |
3697 | 384 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
385 |
WriteLnToConsole('Not using any game controller'); |
2428 | 386 |
end; |
387 |
||
388 |
procedure ControllerAxisEvent(joy, axis: Byte; value: Integer); |
|
7088
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
389 |
var |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
390 |
k: LongInt; |
2428 | 391 |
begin |
7088
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
392 |
SDL_GetKeyState(@k); |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
393 |
k:= k + joy * (ControllerNumAxes[joy]*2 + ControllerNumHats[joy]*4 + ControllerNumButtons[joy]*2); |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
394 |
ProcessKey(k + axis*2, value > 20000); |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
395 |
ProcessKey(k + (axis*2)+1, value < -20000); |
2428 | 396 |
end; |
397 |
||
398 |
procedure ControllerHatEvent(joy, hat, value: Byte); |
|
7088
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
399 |
var |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
400 |
k: LongInt; |
2428 | 401 |
begin |
7088
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
402 |
SDL_GetKeyState(@k); |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
403 |
k:= k + joy * (ControllerNumAxes[joy]*2 + ControllerNumHats[joy]*4 + ControllerNumButtons[joy]*2); |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
404 |
ProcessKey(k + ControllerNumAxes[joy]*2 + hat*4 + 0, (value and SDL_HAT_UP) <> 0); |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
405 |
ProcessKey(k + ControllerNumAxes[joy]*2 + hat*4 + 1, (value and SDL_HAT_RIGHT)<> 0); |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
406 |
ProcessKey(k + ControllerNumAxes[joy]*2 + hat*4 + 2, (value and SDL_HAT_DOWN) <> 0); |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
407 |
ProcessKey(k + ControllerNumAxes[joy]*2 + hat*4 + 3, (value and SDL_HAT_LEFT) <> 0); |
2428 | 408 |
end; |
409 |
||
410 |
procedure ControllerButtonEvent(joy, button: Byte; pressed: Boolean); |
|
7088
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
411 |
var |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
412 |
k: LongInt; |
2428 | 413 |
begin |
7088
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
414 |
SDL_GetKeyState(@k); |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
415 |
k:= k + joy * (ControllerNumAxes[joy]*2 + ControllerNumHats[joy]*4 + ControllerNumButtons[joy]*2); |
dbec9bae4de1
first attempt at fixing controller/gamepad, it works with the android controller but it doesnt have hats/buttons, needs testing
Xeli
parents:
7071
diff
changeset
|
416 |
ProcessKey(k + ControllerNumAxes[joy]*2 + ControllerNumHats[joy]*4 + button, pressed); |
2428 | 417 |
end; |
418 |
||
3038 | 419 |
procedure initModule; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2714
diff
changeset
|
420 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
421 |
wheelUp:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
422 |
wheelDown:= false; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2714
diff
changeset
|
423 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2714
diff
changeset
|
424 |
|
3038 | 425 |
procedure freeModule; |
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6994
diff
changeset
|
426 |
var j: LongInt; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2714
diff
changeset
|
427 |
begin |
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6994
diff
changeset
|
428 |
// close gamepad controllers |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6994
diff
changeset
|
429 |
if ControllerEnabled > 0 then |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6994
diff
changeset
|
430 |
for j:= 0 to pred(ControllerNumControllers) do |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6994
diff
changeset
|
431 |
SDL_JoystickClose(Controller[j]); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2714
diff
changeset
|
432 |
end; |
4 | 433 |
|
434 |
end. |