Hallo,
es ist wieder soweit ;p
Diesmal hab ich die Engine um einen ButtonHandler erweitert. Etwas ähnliches habe ich auch bei Galactica gesehen, nur wollte ich das als Klasse in die Engine integrieren. Demnach heißt die Klasse tbButtonHandler, bekommt das Bool-Array, das man von tbDirectInput::GetState() erhält und ermöglicht damit zu dem KeyPressed() auch einen KeyReleased()-Aufruf. Denn bis jetzt konnte man nur abfragen, ob eine Taste gedrückt ist (soweit ich weiß). Nun kann man auch abfragen, ob eine Taste losgelassen wurde, oder ob sie gerade im Moment des Frames gedrückt wird.
Ich finde so etwas ist vorallem für ein Menü recht wichtig, denn wer kann garantieren, dass die Taste im nächsten Untermenü nicht mehr gedrückt ist? Das würde z.B. dazu führen, dass man mit einem ESC-druck durch 5 Menüs rasselt und womöglich aus dem Spiel fliegt.
Nun gut, wer also Interesse an diese kleine Engine-Erweiterung hat befolge folgende Bastelanleitung:
Man copy diese Header und paste sie in tbButtonHandler.h
|
Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
/********************************************************************
_________ __ _____
/\___ ___\ /\_\ /\ __\
\/__/\ \__/ _ __\/_/_ \ \ \_\\ ____ _____ __
\ \ \ /\`´__\ /\ \ \ \ __\ /\ __\_ /\ __\ /´__`\
\ \ \ \ \ \/ \ \ \ \ \ \_\\\ \\_\ \\ \____\ /\ __/
\ \_\ \ \_\ \ \_\ \ \____\\ \___\ \ \____\\ \____\
\/_/ \/_/ \/_/ \/____/ \/__/ \/____/ \/____/
tbButtonHandler.h
=================
Diese Datei ist Teil der TriBase-Engine.
Zweck:
Umgang Tasten und Knöpfen
Autor:
Snorky
[20.8.2003]
********************************************************************/
#ifndef __TBBUTTONHANDLER__
#define __TBBUTTONHANDLER__
// Klasse für das Keyboard-Verhalten
class TRIBASE_API tbButtonHandler
{
private:
// Variablen
BOOL* m_pbButtonsCurrent; // aktueller Knöpfe Status
BOOL* m_pbButtonsPast; // alter Knöpfe Status
DWORD m_dwNumButtons; // Anzahl der Knöpfe
public:
// Konstruktor und Destruktor
tbButtonHandler();
~tbButtonHandler();
// Methoden
tbResult Exit(); // alles freigeben und zurücksetzen
tbResult Init(DWORD dwButtons); // festlegen wieviele Knöpfe es geben soll
tbResult GetState(BOOL* pbKeys); // aktualisieren der Buttons
BOOL AnyKeyPressed(); // ist irgendeine Taste gedrückt?
BOOL AnyKeyGetPressed(); // wird irgendeine Taste gedrückt?
BOOL AnyKeyReleased(); // wird irgendeine Taste losgelassen?
// Inline-Methoden
// ist die Taste gedrückt?
BOOL KeyPressed(DWORD dwKey) {return (m_pbButtonsCurrent[dwKey]);}
// wird die Taste gerade gedrückt?
BOOL KeyGetPressed(DWORD dwKey) {return (!(m_pbButtonsPast[dwKey]) && (m_pbButtonsCurrent[dwKey]));}
// wird die Taste gerade losgelassen?
BOOL KeyReleased(DWORD dwKey) {return ((m_pbButtonsPast[dwKey]) && !(m_pbButtonsCurrent[dwKey]));}
BOOL* GetButtonsCurrent() {return m_pbButtonsCurrent;}
BOOL* GetButtonsPast() {return m_pbButtonsPast;}
DWORD GetNumButtons() {return m_dwNumButtons;}
};
// ******************************************************************
#endif __TBBUTTONHANDLER__
|
Nun tue man das Gleiche mit der tbButtonHandler.cpp
|
Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
/********************************************************************
_________ __ _____
/\___ ___\ /\_\ /\ __\
\/__/\ \__/ _ __\/_/_ \ \ \_\\ ____ _____ __
\ \ \ /\`´__\ /\ \ \ \ __\ /\ __\_ /\ __\ /´__`\
\ \ \ \ \ \/ \ \ \ \ \ \_\\\ \\_\ \\ \____\ /\ __/
\ \_\ \ \_\ \ \_\ \ \____\\ \___\ \ \____\\ \____\
\/_/ \/_/ \/_/ \/____/ \/__/ \/____/ \/____/
tbButtonHandler.cpp
===================
Diese Datei ist Teil der TriBase-Engine.
Zweck:
Umgang Tasten und Knöpfen
Autor:
Snorky
[20.8.2003]
********************************************************************/
#include <TriBase.h>
// ******************************************************************
// Konsturktor
tbButtonHandler::tbButtonHandler()
{
// Alles zurücksetzen
ZeroMemory(this, sizeof(tbButtonHandler));
}
// ******************************************************************
// Destruktor
tbButtonHandler::~tbButtonHandler()
{
Exit();
}
// ******************************************************************
// alles freigeben und zurücksetzen
tbResult tbButtonHandler::Exit()
{
// Arrays freigeben
TB_SAFE_DELETE_ARRAY(m_pbButtonsCurrent);
TB_SAFE_DELETE_ARRAY(m_pbButtonsPast);
// Alles zurücksetzen
ZeroMemory(this, sizeof(tbButtonHandler));
return TB_OK;
}
// ******************************************************************
// festlegen wieviele Knöpfe es geben soll
tbResult tbButtonHandler::Init(DWORD dwButtons)
{
// sicherheitshalber alles vorher freigeben
Exit();
// Knopfanzahl setzen
m_dwNumButtons = dwButtons;
// Speicher für Knöpfe belegen
m_pbButtonsCurrent = new BOOL [m_dwNumButtons];
if(m_pbButtonsCurrent == NULL)
{
// Fehler!
TB_ERROR_OUT_OF_MEMORY(TB_ERROR);
}
m_pbButtonsPast = new BOOL [m_dwNumButtons];
if(m_pbButtonsPast == NULL)
{
// Fehler!
TB_ERROR_OUT_OF_MEMORY(TB_ERROR);
}
// Tasten mit FALSE vorbelegen
ZeroMemory((void*)m_pbButtonsCurrent, m_dwNumButtons * sizeof(BOOL));
ZeroMemory((void*)m_pbButtonsPast, m_dwNumButtons * sizeof(BOOL));
return TB_OK;
}
// ******************************************************************
// aktualisieren der Buttons
tbResult tbButtonHandler::GetState(BOOL* pbKeys)
{
// aktuellen Stand zum alten machen
memcpy(m_pbButtonsPast, m_pbButtonsCurrent, m_dwNumButtons*sizeof(BOOL));
// aktuellen Stand durch neuen ersetzen
memcpy(m_pbButtonsCurrent, pbKeys, m_dwNumButtons*sizeof(BOOL));
return TB_OK;
}
// ******************************************************************
// ist irgendeine Taste gedrückt?
BOOL tbButtonHandler::AnyKeyPressed()
{
DWORD dw;
// Alle Tastaturtasten durchgehen
for(dw = 0; dw <= 107; dw++)
{
if(m_pbButtonsCurrent[dw])
return TRUE;
}
// Maustasten auch checken
for(dw = 114; dw <= 121; dw++)
{
if(m_pbButtonsCurrent[dw])
return TRUE;
}
// nichts gefunden
return FALSE;
}
// ******************************************************************
// wird irgendeine Taste gedrückt?
BOOL tbButtonHandler::AnyKeyGetPressed()
{
DWORD dw;
// Alle Tastaturtasten durchgehen
for(dw = 0; dw <= 107; dw++)
{
if(!(m_pbButtonsPast[dw]) && m_pbButtonsCurrent[dw])
return TRUE;
}
// Maustasten auch checken
for(dw = 114; dw <= 121; dw++)
{
if(!(m_pbButtonsPast[dw]) && m_pbButtonsCurrent[dw])
return TRUE;
}
// nichts gefunden
return FALSE;
}
// ******************************************************************
// wird irgendeine Taste losgelassen?
BOOL tbButtonHandler::AnyKeyReleased()
{
DWORD dw;
// Alle Tastaturtasten durchgehen
for(dw = 0; dw <= 107; dw++)
{
if(m_pbButtonsPast[dw] && !(m_pbButtonsCurrent[dw]))
return TRUE;
}
// Maustasten auch checken
for(dw = 114; dw <= 121; dw++)
{
if(m_pbButtonsPast[dw] && !(m_pbButtonsCurrent[dw]))
return TRUE;
}
// nichts gefunden
return FALSE;
}
// ******************************************************************
|
Zum Schluß füge noch den Include in die TriBase.h ein und es kann folgendermaßen verwendet werden:
|
Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
// Variablendefinition
float* g_pfButtons = NULL; // Analoges Verhalten der Knöpfe
BOOL* g_pbButtons = NULL; // Digitales Verhalten der Knöpfe
tbButtonHandler* g_pButtons = NULL; // Inputverhalten der Knöpfe
// Nach tbDirectInput::Init()
// Speicher für die Knöpfe reservieren
g_pfButtons = new float[tbDirectInput::GetNumButtons()];
g_pbButtons = new BOOL[tbDirectInput::GetNumButtons()];
g_pButtons = new tbButtonHandler;
g_pButtons->Init(tbDirectInput::GetNumButtons());
// In der Move-Methode
// Eingabegeräte abfragen
tbDirectInput::GetState(g_pfButtons, g_pbButtons);
g_pButtons->GetState(g_pbButtons);
// Und der eigentlich Sinn des Ganzen
// An gegebener Stelle z.B. das Programm beenden,
// wenn die ESC-Taste losgelassen wird. Nicht vorher!
if(g_pButtons->KeyReleased(TB_KEY_ESCAPE)) PostQuitMessage(0);
// Speicher natürlich an der richtigen Stelle wieder freigeben
TB_SAFE_DELETE(g_pButtons);
TB_SAFE_DELETE_ARRAY(g_pfButtons);
TB_SAFE_DELETE_ARRAY(g_pbButtons);
|
Das wäre eigentlich auch schon alles. Für Titelbilder würde sich auch die AnyKeyReleased() hervorragend anbieten, aber probiert selber.
Viel Spaß