/zoeplat

To get this branch, use:
bzr branch http://9ix.org/bzr/zoeplat

« back to all changes in this revision

Viewing changes to zoetrope/input/keys.lua

  • Committer: Josh C
  • Date: 2013-03-04 23:27:03 UTC
  • Revision ID: josh@9ix.org-20130304232703-nob2mg5wbo5co5is
basic tiles, map, player, movement

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
--
2
 
--
3
 
--
4
 
--              <Sprite>
5
 
 
6
 
Keys = Sprite:extend
7
 
{
8
 
        visible = false,
9
 
 
10
 
        -- Property: typed
11
 
        -- This is literally what is being typed during the current frame.
12
 
        -- e.g. if the user holds the shift key and presses the 'a' key,
13
 
        -- this will be set to 'A'. Consult <allPressed()> if you
14
 
        -- want to know what specific keys are being pressed.
15
 
 
16
 
        typed = '',
17
 
 
18
 
        -- private property: _thisFrame
19
 
        -- what keys are pressed this frame
20
 
        -- if you are interested in this, use allPressed() instead
21
 
 
22
 
        _thisFrame = {},
23
 
 
24
 
        -- private property: _lastFrame
25
 
        -- what keys were pressed last frame
26
 
        
27
 
        _lastFrame = {},
28
 
        
29
 
        new = function (self, obj)
30
 
                obj = self:extend(obj)
31
 
                the.keys = obj
32
 
                love.keypressed = function (key, unicode) obj:keyPressed(key, unicode) end
33
 
                love.keyreleased = function (key, unicode) obj:keyReleased(key, unicode) end
34
 
                if obj.onNew then obj:onNew() end
35
 
                return obj
36
 
        end,
37
 
        
38
 
        -- Method: pressed
39
 
        -- Are *any* of the keys passed held down this frame?
40
 
        --
41
 
        -- Arguments:
42
 
        --              string key descriptions passed as individual arguments
43
 
        --
44
 
        -- Returns:
45
 
        --              boolean
46
 
 
47
 
        pressed = function (self, ...)
48
 
                local keys = {...}
49
 
                for _, value in pairs(keys) do
50
 
                        if STRICT then
51
 
                                assert(type(value) == 'string', 'all keys are strings; asked to check a ' .. type(value))
52
 
                        end
53
 
 
54
 
                        if self._thisFrame[value] then
55
 
                                return true
56
 
                        end
57
 
                end
58
 
                
59
 
                return false
60
 
        end,
61
 
 
62
 
        -- Method: justPressed
63
 
        -- Are *any* of the keys passed pressed for the first time this frame?
64
 
        --
65
 
        -- Arguments:
66
 
        --              string key descriptions passed as individual arguments
67
 
        --
68
 
        -- Returns:
69
 
        --              boolean
70
 
 
71
 
        justPressed = function (self, ...)
72
 
                local keys = {...}
73
 
 
74
 
                for _, value in pairs(keys) do
75
 
                        if STRICT then
76
 
                                assert(type(value) == 'string', 'all keys are strings; asked to check a ' .. type(value))
77
 
                        end
78
 
 
79
 
                        if self._thisFrame[value] and not self._lastFrame[value] then
80
 
                                return true
81
 
                        end
82
 
                end
83
 
                
84
 
                return false
85
 
        end,
86
 
 
87
 
        -- Method: released
88
 
        -- Are *all* of the keys passed not held down this frame?
89
 
        -- 
90
 
        -- Arguments:
91
 
        --              string key descriptions passed as individual arguments
92
 
        --
93
 
        -- Returns:
94
 
        --              boolean
95
 
 
96
 
        released = function (self, ...)
97
 
                local keys = {...}
98
 
 
99
 
                for _, value in pairs(keys) do
100
 
                        if STRICT then
101
 
                                assert(type(value) == 'string', 'all keys are strings; asked to check a ' .. type(value))
102
 
                        end
103
 
 
104
 
                        if self._thisFrame[value] then
105
 
                                return false
106
 
                        end
107
 
                end
108
 
                
109
 
                return true
110
 
        end,
111
 
 
112
 
        -- Method: justReleased
113
 
        -- Are *any* of the keys passed released after being held last frame?
114
 
        --
115
 
        -- Arguments:
116
 
        --              string key descriptions passed as individual arguments
117
 
        --
118
 
        -- Returns:
119
 
        --              boolean
120
 
 
121
 
        justReleased = function (self, ...)
122
 
                local keys = {...}
123
 
 
124
 
                for _, value in pairs(keys) do
125
 
                        if STRICT then
126
 
                                assert(type(value) == 'string', 'all keys are strings; asked to check a ' .. type(value))
127
 
                        end
128
 
 
129
 
                        if self._lastFrame[value] and not self._thisFrame[value] then
130
 
                                return true
131
 
                        end
132
 
                end
133
 
                
134
 
                return false
135
 
        end,
136
 
 
137
 
        -- Method: allPressed
138
 
        -- Returns all buttons currently pressed this frame.
139
 
        --
140
 
        -- Arguments:
141
 
        --              none
142
 
        --
143
 
        -- Returns:
144
 
        --              string key descriptions; if nothing is pressed, nil
145
 
 
146
 
        allPressed = function (self)
147
 
                local result = {}
148
 
 
149
 
                for key, value in pairs(self._thisFrame) do
150
 
                        if value then table.insert(result, key) end
151
 
                end
152
 
                
153
 
                return unpack(result)
154
 
        end,
155
 
 
156
 
        -- Method: allJustPressed
157
 
        -- Returns all keys just pressed this frame.
158
 
        --
159
 
        -- Arguments:
160
 
        --              none
161
 
        --
162
 
        -- Returns:
163
 
        --              string key descriptions; if nothing is just pressed, nil
164
 
 
165
 
        allJustPressed = function (self)
166
 
                local result = {}
167
 
 
168
 
                for key, value in pairs(self._thisFrame) do
169
 
                        if value and not self._lastFrame[key] then table.insert(result, key) end
170
 
                end
171
 
                
172
 
                return unpack(result)
173
 
        end,
174
 
 
175
 
        -- Method: allJustReleased
176
 
        -- Returns all keys just released this frame.
177
 
        --
178
 
        -- Arguments:
179
 
        --              none
180
 
        --
181
 
        -- Returns:
182
 
        --              string key descriptions; if nothing is just pressed, nil
183
 
 
184
 
        allJustReleased = function (self)
185
 
                local result = {}
186
 
 
187
 
                for key, value in pairs(self._thisFrame) do
188
 
                        if not value and self._lastFrame[key] then table.insert(result, key) end
189
 
                end
190
 
                
191
 
                return unpack(result)
192
 
        end,
193
 
 
194
 
        -- Converts a character code to a Unicode string
195
 
        -- see http://stackoverflow.com/questions/7780179/what-is-the-way-to-represent-a-unichar-in-lua/7799843
196
 
 
197
 
        unicodeChar = function (self, code)
198
 
                if code == nil then return nil end
199
 
                if code < 32 then return string.format('\\x%02x', code) end
200
 
                if code < 126 then return string.char(code) end
201
 
                if code < 65539 then return string.format("\\u%04x", code) end
202
 
                if code < 1114111 then return string.format("\\u%08x", code) end
203
 
        end,
204
 
 
205
 
        -- Connects to the love.keypressed callback
206
 
 
207
 
        keyPressed = function (self, key, unicode)
208
 
                self._thisFrame[key] = true
209
 
                if unicode and unicode >= 0x20 and unicode ~= 127 and unicode < 0x3000 then
210
 
                        self.typed = self.typed .. self:unicodeChar(unicode)
211
 
                end
212
 
 
213
 
                -- aliases for modifiers
214
 
 
215
 
                if key == 'rshift' or key == 'lshift' or
216
 
                   key == 'rctrl' or key == 'lctrl' or
217
 
                   key == 'ralt' or key == 'lalt' or
218
 
                   key == 'rmeta' or key == 'lmeta' or
219
 
                   key == 'rsuper' or key == 'lsuper' then
220
 
                        self._thisFrame[string.sub(key, 2)] = true
221
 
                end
222
 
        end,
223
 
 
224
 
        -- Connects to the love.keyreleased callback
225
 
 
226
 
        keyReleased = function (self, key, unicode)
227
 
                self._thisFrame[key] = false
228
 
 
229
 
                -- aliases for modifiers
230
 
 
231
 
                if key == 'rshift' or key == 'lshift' or
232
 
                   key == 'rctrl' or key == 'lctrl' or
233
 
                   key == 'ralt' or key == 'lalt' or
234
 
                   key == 'rmeta' or key == 'lmeta' or
235
 
                   key == 'rsuper' or key == 'lsuper' then
236
 
                        self._thisFrame[string.sub(key, 2)] = false
237
 
                end
238
 
        end,
239
 
 
240
 
        endFrame = function (self, elapsed)
241
 
                for key, value in pairs(self._thisFrame) do
242
 
                        self._lastFrame[key] = value
243
 
                end
244
 
 
245
 
                self.typed = ''
246
 
                Sprite.endFrame(self, elapsed)
247
 
        end,
248
 
 
249
 
        update = function() end
250
 
}