summaryrefslogtreecommitdiffstats
path: root/apps/plugins/boomshine.lua
blob: c7ed6dfdf1ba2b47f41c699a062e71b386f4a206 (plain)
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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
--[[
             __________               __   ___.
   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
                     \/            \/     \/    \/            \/
 $Id$

 Port of Chain Reaction (which is based on Boomshine) to Rockbox in Lua.
 See http://www.yvoschaap.com/chainrxn/ and http://www.k2xl.com/games/boomshine/

 Copyright (C) 2009 by Maurus Cuelenaere
 Copyright (C) 2018 William Wilgus -- Added circles, logic rewrite, hard levels

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 KIND, either express or implied.

]]--
require "actions"
--[[only save the actions we are using]]
pla = {}
for key, val in pairs(rb.actions) do
    for _, v in ipairs({"PLA_", "TOUCHSCREEN", "_NONE"}) do
        if string.find (key, v) then
            pla[key] = val; break
        end
    end
end
rb.actions, rb.contexts = nil, nil
--------------------------------------

local _LCD = rb.lcd_framebuffer()
local rocklib_image = getmetatable(_LCD)
local _ellipse = rocklib_image.ellipse
local BSAND = 0x8
local irand = math.random

local HAS_TOUCHSCREEN = rb.action_get_touchscreen_press ~= nil
local LCD_H, LCD_W = rb.LCD_HEIGHT, rb.LCD_WIDTH
local DEFAULT_BALL_SZ = LCD_H > LCD_W and LCD_W  / 30 or LCD_H / 30
      DEFAULT_BALL_SZ = DEFAULT_BALL_SZ - bit.band(DEFAULT_BALL_SZ, 1)
local MAX_BALL_SPEED = DEFAULT_BALL_SZ / 2 + 1
-- Ball states
local B_DEAD, B_MOVE, B_EXPLODE, B_DIE, B_WAIT, B_IMPLODE = 5, 4, 3, 2, 1, 0

local DEFAULT_FG_CLR = 1
local DEFAULT_BG_CLR = 0
if rb.lcd_get_foreground ~= nil then
    DEFAULT_FG_CLR = rb.lcd_get_foreground()
    DEFAULT_BG_CLR = rb.lcd_get_background()
elseif rb.LCD_DEFAULT_FG ~= nil then
    DEFAULT_FG_CLR = rb.LCD_DEFAULT_FG
    DEFAULT_BG_CLR = rb.LCD_DEFAULT_BG
end

local FMT_EXPEND, FMT_LEVEL = "%d balls expended", "Level %d"
local FMT_TOTPTS, FMT_LVPTS = "%d total points", "%d level points"

local levels = {
            --  {GOAL, TOTAL_BALLS},
                {1,   5},
                {2,  10},
                {4,  15},
                {6,  20},
                {10, 25},
                {15, 30},
                {18, 35},
                {22, 40},
                {30, 45},
                {37, 50},
                {48, 55},
                {58, 60},
                {28, 30},
                {23, 25},
                {18, 20},
                {13, 15},
                {8,  10},
                {9,  10},
                {4,   5},
                {5,   5}
            }

local function getstringsize(str)
        local _, w, h = rb.font_getstringsize(str, rb.FONT_UI)
        return w, h
end

local function set_foreground(color)
    if rb.lcd_set_foreground ~= nil then
        rb.lcd_set_foreground(color)
    end
end

local function random_color()
    if rb.lcd_rgbpack ~= nil then -- color target
        return rb.lcd_rgbpack(irand(1,255), irand(1,255), irand(1,255))
    end

    local color = irand(1, rb.LCD_DEPTH)
    color = (rb.LCD_DEPTH == 2) and (3 - color) or color -- invert for 2-bit screens

    return color
end

local Ball = {
                -- Ball defaults
                sz = DEFAULT_BALL_SZ,
                next_tick = 0,
                state = B_MOVE
             }

function Ball:new(o, level)
    if o == nil then
        level = level or 1
        local maxdelay = (level <= 5) and 10 or level
        o = {
                x = irand(1, LCD_W - self.sz),
                y = irand(1, LCD_H - self.sz),
                color = random_color(),
                xi = Ball:genSpeed(),
                yi = Ball:genSpeed(),
                step_delay    = irand(3, maxdelay / 2),
                explosion_sz  = irand(2 * self.sz, 4 * self.sz),
                life_ticks = irand(rb.HZ / level, rb.HZ * (maxdelay / 5))
            }
    end
    o.life_ticks = o.life_ticks + DEFAULT_BALL_SZ -- extra time for larger screens
    setmetatable(o, self)
    self.__index = self
    return o
end

function Ball:genSpeed()
    local speed = irand(-MAX_BALL_SPEED, MAX_BALL_SPEED)
    return speed ~= 0 and speed or MAX_BALL_SPEED -- Make sure all balls move
end

function Ball:draw()
    _ellipse(_LCD, self.x, self.y,
             self.x + self.sz, self.y + self.sz , self.color, self.color, true)
end

function Ball:step(tick)
    self.next_tick = tick + self.step_delay
    self.x = self.x + self.xi
    self.y = self.y + self.yi

    if (self.x <= 0 or self.x >= (LCD_W - self.sz)) then
        self.xi = -self.xi
        self.x  = self.x + self.xi
    end

    if (self.y <= 0 or self.y >= (LCD_H - self.sz)) then
        self.yi = -self.yi
        self.y  = self.y + self.yi
    end
end

function Ball:checkHit(other)
    if (other.xi >= self.x) and (other.yi >= self.y) and
        (self.x + self.sz >= other.x) and (self.y + self.sz >= other.y) then
        self.state = B_EXPLODE
        -- x/y increment no longer needed it is now impact region
        self.xi = self.x + self.sz
        self.yi = self.y + self.sz

        if other.state < B_EXPLODE then -- add duration to the ball that got hit
            other.next_tick = other.next_tick + self.life_ticks
        end
        return true
    end

    return false
end

function Ball:draw_exploded()
    _ellipse(_LCD, self.x, self.y, self.xi, self.yi, self.color, nil, true)
end

function Ball:step_exploded(tick)
    -- exploding ball state machine
    -- B_EXPLODE >> B_DIE >> BWAIT >> B_IMPLODE >> B_DEAD
    if self.state == B_EXPLODE and self.sz < self.explosion_sz then
        self.sz = self.sz + 2
        self.x  = self.x - 1 -- We do this because we want to stay centered
        self.y  = self.y - 1
    elseif self.state == B_DIE then
        self.state = B_WAIT
        self.next_tick = tick + self.life_ticks
        return
    elseif self.state == B_IMPLODE and self.sz > 0 then
        self.sz = self.sz - 2
        self.x  = self.x + 1 -- We do this because we want to stay centered
        self.y  = self.y + 1
    elseif self.state <= B_IMPLODE then
        self.state = B_DEAD
        return
    elseif self.next_tick < tick then
        self.state = self.state - 1
        return
    end
    -- fell through, update next_tick and impact region
    self.next_tick = tick + self.step_delay
    self.xi = self.x + self.sz
    self.yi = self.y + self.sz
end

local Cursor = {
                sz = (DEFAULT_BALL_SZ * 2),
                x  = (LCD_W / 2),
                y  = (LCD_H / 2),
                color = DEFAULT_FG_CLR
             }

function Cursor:new()
    if rb.LCD_DEPTH == 2 then -- invert for 2 - bit screens
        self.color = 3 - DEFAULT_FG_CLR
    end
    self:create_image(DEFAULT_BALL_SZ * 2)
    return self
end

function Cursor:create_image(sz)
    if not HAS_TOUCHSCREEN then
        sz = sz + 1
        local img = rb.new_image(sz, sz)
        local sz2 = (sz / 2) + 1
        local sz4 = (sz / 4)

        img:clear(0)
        img:line(1, 1, sz4 + 1, 1, 1)
        img:line(1, 1, 1, sz4 + 1, 1)

        img:line(1, sz, sz4 + 1, sz, 1)
        img:line(1, sz, 1, sz - sz4, 1)

        img:line(sz, sz, sz - sz4, sz, 1)
        img:line(sz, sz, sz, sz - sz4, 1)

        img:line(sz, 1, sz - sz4, 1, 1)
        img:line(sz, 1, sz, sz4 + 1, 1)

        -- crosshairs
        img:line(sz2 - sz4, sz2, sz2 + sz4, sz2, 1)
        img:line(sz2, sz2 - sz4, sz2, sz2 + sz4, 1)
        self.image = img
    end
end

local function clamp_roll(iVal, iMin, iMax)
    if iVal < iMin then
        iVal = iMax
    elseif iVal > iMax then
        iVal = iMin
    end

    return iVal
end

function Cursor:do_action(action)
    local xi, yi = 0, 0

    if HAS_TOUCHSCREEN and action == pla.ACTION_TOUCHSCREEN then
        _, self.x, self.y = rb.action_get_touchscreen_press()
        return true
    elseif action == pla.PLA_SELECT then
        return true
    elseif (action == pla.PLA_RIGHT or action == pla.PLA_RIGHT_REPEAT) then
        xi = self.sz
    elseif (action == pla.PLA_LEFT or action == pla.PLA_LEFT_REPEAT) then
        xi = -self.sz
    elseif (action == pla.PLA_UP or action == pla.PLA_UP_REPEAT) then
        yi = -self.sz
    elseif (action == pla.PLA_DOWN or action == pla.PLA_DOWN_REPEAT) then
        yi = self.sz
    end

    self.x = clamp_roll(self.x + xi, 1, LCD_W - self.sz)
    self.y = clamp_roll(self.y + yi, 1, LCD_H - self.sz)

    return false
end

function Cursor:draw()
    rocklib_image.copy(_LCD, self.image, self.x, self.y, _NIL, _NIL,
                       _NIL, _NIL, true, BSAND, self.color)
end

local function calc_score(total, level, goal, expended)
    local score = (expended * level) * 100
    if expended < goal then
      score = -(score + (level * 100))
    end
    total = total + score
    return total
end

local function draw_pos_str(bottom, right, str)
    local w, h = getstringsize(str)
    local x = (right > 0) and ((LCD_W - w) * right - 1) or 1
    local y = (bottom > 0) and ((LCD_H - h) * bottom - 1) or 1
    rb.lcd_putsxy(x, y, str)
end

local function wait_anykey(to_secs)
    rb.sleep(rb.HZ / 2)
    rb.button_clear_queue()
    rb.button_get_w_tmo(rb.HZ * to_secs)
end

local function start_round(level, goal, nrBalls, total)
    local player_added, score = false, 0
    local last_expend, nrBalls_expend = 0, 0
    local balls_exploded = 1 -- keep looping when player_added == false
    local action = 0
    local Balls = {}
    local str_level = string.format(FMT_LEVEL, level) -- static
    local str_totpts = string.format(FMT_TOTPTS, total) -- static
    local str_expend, str_lvlpts
    local tick, cursor
    local test_spd = false

    local function update_stats()
        -- we only create a new string when a hit is detected
        str_expend = string.format(FMT_EXPEND, nrBalls_expend)
        str_lvlpts = string.format(FMT_LVPTS, score)
    end

    local function draw_stats()
        draw_pos_str(0, 0, str_expend)
        draw_pos_str(0, 1, str_level)
        draw_pos_str(1, 1, str_lvlpts)
        draw_pos_str(1, 0, str_totpts)
    end

    local function add_player()
        -- cursor becomes exploded ball
        local player = Ball:new({
                            x = cursor.x,
                            y = cursor.y,
                            color = cursor.color,
                            step_delay = 3,
                            explosion_sz = (3 * DEFAULT_BALL_SZ),
                            life_ticks = (test_time == true) and (100) or 
                                        irand(rb.HZ * 2, rb.HZ * DEFAULT_BALL_SZ),
                            sz = 10,
                            state = B_EXPLODE
                        })
        -- set x/y impact region
        player.xi = player.x + player.sz
        player.yi = player.y + player.sz

        table.insert(Balls, player)
        balls_exploded = 1
        player_added = true
        cursor = nil
    end

    if level < 1 then
        -- check speed of target
        set_foreground(DEFAULT_BG_CLR) --hide text during test
        local bkcolor = (rb.LCD_DEPTH == 2) and (3) or 0
        level = 1
        nrBalls = 20
        cursor = { x = LCD_W * 2, y = LCD_H * 2, color = bkcolor}
        table.insert(Balls, Ball:new({
                            x = 1, y = 1, xi = 1, yi = 1,
                            color = bkcolor, step_delay = 1,
                            explosion_sz = 0, life_ticks = 0,
                            step = function() test_spd = test_spd + 1 end
                        })
                    )
        add_player()
        test_spd = 0
    else
        set_foreground(DEFAULT_FG_CLR) -- color for text
        cursor = Cursor:new()
    end

    -- Initialize the balls
    for i=1, nrBalls do
        table.insert(Balls, Ball:new(nil, level))
    end

    -- Make sure there are no unwanted touchscreen presses
    rb.button_clear_queue()

    update_stats() -- load status strings

     -- Check if the round is over
    while balls_exploded > 0 do
        tick = rb.current_tick()

        if action ~= pla.ACTION_NONE and (action == pla.PLA_EXIT or
                                          action == pla.PLA_CANCEL) then
            action = pla.PLA_EXIT
            break
        end

        rb.lcd_clear_display()

        if not player_added then
            if action ~= pla.ACTION_NONE and cursor:do_action(action) then
                add_player()
            elseif not HAS_TOUCHSCREEN then
                cursor:draw()
            end
        end

        for _, Ball in ipairs(Balls) do
            if Ball.state == B_MOVE then
                if tick > Ball.next_tick then
                    Ball:step(tick)
                    for i = #Balls, 1, -1 do
                        if Balls[i].state < B_MOVE and
                            Ball:checkHit(Balls[i]) then -- exploded?
                                balls_exploded = balls_exploded + 1
                                nrBalls_expend = nrBalls_expend + 1
                                break
                        end
                    end
                end
                -- check if state changed draw ball if still moving
                if Ball.state == B_MOVE then
                    Ball:draw()
                end
            elseif Ball.state ~= B_DEAD then
                if tick > Ball.next_tick then
                    Ball:step_exploded(tick)
                end
                if Ball.state ~= B_DEAD then
                    Ball:draw_exploded()
                else
                    balls_exploded = balls_exploded - 1
                end
            end
        end

        draw_stats() -- stats redrawn every frame
        rb.lcd_update() -- Push framebuffer to the LCD

        if nrBalls_expend ~= last_expend then -- hit detected?
            last_expend = nrBalls_expend
            score = (nrBalls_expend * level) * 100
            update_stats() -- only update stats when not current
            if nrBalls_expend == nrBalls then break end -- round is over?
        end

        rb.yield() -- yield to other tasks

        action = rb.get_plugin_action(0) -- Check for actions
    end

    if test_spd and test_spd > 0 then return test_spd end

    -- splash the final stats for a moment at end
    rb.lcd_clear_display()
    for _, Ball in ipairs(Balls) do
        -- move balls back to their initial exploded positions
        if Ball.state == B_DEAD then
            Ball.sz = Ball.explosion_sz + 2
            Ball.x  = Ball.x - (Ball.explosion_sz / 2)
            Ball.y  = Ball.y - (Ball.explosion_sz / 2)
        end
        Ball:draw()
    end

    if DEFAULT_BALL_SZ > 3 then
        _LCD:clear(nil, nil, nil, nil, nil, nil, 2, 2)
    end

    total = calc_score(total, level, goal, nrBalls_expend)
    str_totpts = string.format(FMT_TOTPTS, total)
    draw_stats()
    rb.lcd_update()
    wait_anykey(2)

    return action == pla.PLA_EXIT, score, nrBalls_expend
end

-- Helper function to display a message
local function disp_msg(to, ...)
    local message = string.format(...)
    local w, h = getstringsize(message)
    local x, y = (LCD_W - w) / 2, (LCD_H - h) / 2

    rb.lcd_clear_display()
    set_foreground(DEFAULT_FG_CLR)

    if w > LCD_W then
        rb.lcd_puts_scroll(0, (y / h), message)
    else
        rb.lcd_putsxy(x, y, message)
    end

    if to == -1 then
        local msg = "Press button to exit"
        w, h = getstringsize(msg)
        x = (LCD_W - w) / 2
        if x < 0 then
            rb.lcd_puts_scroll(0, (y / h) + 1, msg)
        else
            rb.lcd_putsxy(x, y + h, msg)
        end
    end
    rb.lcd_update()

    if to == -1 then
        wait_anykey(60)
    else
        rb.sleep(to)
    end

    rb.lcd_scroll_stop() -- Stop our scrolling message
end

--[[MAIN PROGRAM]]
do  -- attempt to get stats to fit on screen
    local function getwidth(str)
        local w, _ = getstringsize(str)
        return w
    end
    local w0, w1 = getwidth(FMT_EXPEND), getwidth(FMT_LEVEL)
    if (w0 + w1) > LCD_W then
        FMT_EXPEND, FMT_LEVEL = "%d balls", "Lv %d"
    end
    w0, w1 = getwidth(FMT_TOTPTS), getwidth(FMT_LVPTS) 
    if (w0 + w1 + getwidth("0000000")) > LCD_W then
        FMT_TOTPTS, FMT_LVPTS = "%d total", "%d lv"
    end
end

if HAS_TOUCHSCREEN then
    rb.touchscreen_mode(rb.TOUCHSCREEN_POINT)
end

rb.backlight_force_on()

math.randomseed(os.time())

local idx, highscore = 1, 0

local test_spd = start_round(0, 0, 0, 0) -- test speed of target

if test_spd < 100 then 
    rb.splash(100, "Slow Target..")

    if test_spd < 25 then
        MAX_BALL_SPEED = MAX_BALL_SPEED + MAX_BALL_SPEED
    elseif  test_spd < 50 then
        MAX_BALL_SPEED = MAX_BALL_SPEED + MAX_BALL_SPEED / 2
    elseif  test_spd < 100 then
        MAX_BALL_SPEED = MAX_BALL_SPEED + MAX_BALL_SPEED / 4
    end
end

while levels[idx] ~= nil do
    local goal, nrBalls = levels[idx][1], levels[idx][2]

    collectgarbage("collect") -- run gc now to hopefully prevent interruption later

    disp_msg(rb.HZ * 2, "Level %d: get %d out of %d balls", idx, goal, nrBalls)

    local exit, score, nrBalls_expend = start_round(idx, goal, nrBalls, highscore)

    if exit then
        break -- Exiting..
    else
        highscore = calc_score(highscore, idx, goal, nrBalls_expend)
        if nrBalls_expend >= goal then
            disp_msg(rb.HZ * 2, "You won!")
            levels[idx] = nil
            idx = idx + 1
        else
            disp_msg(rb.HZ * 2, "You lost %d points!", score + (idx * 100))
            if highscore < 0 then break end
        end
    end
end

if highscore <= 0 then
    disp_msg(-1, "You lost at level %d", idx)
elseif idx > #levels then
    disp_msg(-1, "You finished the game with %d points!", highscore)
else
    disp_msg(-1, "You made it till level %d with %d points!", idx, highscore)
end

-- Restore user backlight settings
rb.backlight_use_settings()