/ld27

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

« back to all changes in this revision

Viewing changes to zoetrope/sprites/map.lua

  • Committer: Josh C
  • Date: 2014-07-06 22:51:43 UTC
  • Revision ID: josh@9ix.org-20140706225143-q72jn0va7v4ssvyy
ignore lovebird, inspect

Show diffs side-by-side

added added

removed removed

Lines of Context:
zoetrope/sprites/map.lua
27
27
        -- nb. The tile at (0, 0) visually is stored in [1, 1].
28
28
        map = {},
29
29
 
 
30
        spriteBatches = {},
 
31
        prevStartX = nil,
 
32
        prevStartY = nil,
 
33
        prevEndX = nil,
 
34
        prevEndY = nil,
 
35
 
30
36
        -- Method: empty
31
37
        -- Creates an empty map.
32
38
        --
339
345
                -- determine drawing bounds
340
346
                -- we draw to fill the entire app windoow
341
347
                
342
 
                local startX, startY = self:pixelToMap(-x, -y)
343
 
                local endX, endY = self:pixelToMap(the.app.width - x, the.app.height - y)
344
 
                
345
 
                -- queue each sprite drawing operation
346
 
                
347
 
                local toDraw = {}
348
 
                
349
 
                for drawY = startY, endY do
350
 
                        for drawX = startX, endX do
351
 
                                local sprite = self.sprites[self.map[drawX][drawY]]
352
 
                                
353
 
                                if sprite and sprite.visible then
354
 
                                        if not toDraw[sprite] then
355
 
                                                toDraw[sprite] = {}
 
348
                --local startX, startY = self:pixelToMap(-x, -y)
 
349
                --local endX, endY = self:pixelToMap(the.app.width - x, the.app.height - y)
 
350
                local startX, startY = 1, 1
 
351
                local endX, endY = self:getMapSize()
 
352
 
 
353
                -- if using spritebatches, check if anything has changed
 
354
                -- TODO: encapsulate this check?
 
355
                if startX ~= self.prevStartX or
 
356
                        startY ~= self.prevStartY or
 
357
                        endX ~= self.prevEndX or
 
358
                        endY ~= self.prevEndY then
 
359
 
 
360
                        --print('building sprite batch')
 
361
 
 
362
                        self.prevStartX, self.prevStartY = startX, startY
 
363
                        self.prevEndX, self.prevEndY = endX, endY
 
364
 
 
365
                        for k, batch in pairs(self.spriteBatches) do
 
366
                                --batch:bind()
 
367
                                batch:clear()
 
368
                        end
 
369
 
 
370
                        -- queue each sprite drawing operation
 
371
 
 
372
                        local toDraw = {}
 
373
 
 
374
                        for drawY = startY, endY do
 
375
                                for drawX = startX, endX do
 
376
                                        local sprite = self.sprites[self.map[drawX][drawY]]
 
377
 
 
378
                                        if sprite and sprite.visible then
 
379
                                                if not toDraw[sprite] then
 
380
                                                        toDraw[sprite] = {}
 
381
                                                end
 
382
 
 
383
                                                table.insert(toDraw[sprite], { (drawX - 1) * self.spriteWidth,
 
384
                                                                               (drawY - 1) * self.spriteHeight })
356
385
                                        end
357
 
                                        
358
 
                                        table.insert(toDraw[sprite], { x + (drawX - 1) * self.spriteWidth,
359
 
                                                                                                   y + (drawY - 1) * self.spriteHeight })
 
386
                                end
 
387
                        end
 
388
 
 
389
                        -- draw each sprite in turn
 
390
 
 
391
                        for sprite, list in pairs(toDraw) do
 
392
                                for _, coords in pairs(list) do
 
393
                                        sprite:draw(coords[1], coords[2], self)
360
394
                                end
361
395
                        end
362
396
                end
363
 
                
364
 
                -- draw each sprite in turn
365
 
                
366
 
                for sprite, list in pairs(toDraw) do
367
 
                        for _, coords in pairs(list) do
368
 
                                sprite:draw(coords[1], coords[2])
369
 
                        end
 
397
 
 
398
                for _, batch in pairs(self.spriteBatches) do
 
399
                        --batch:unbind()
 
400
                        love.graphics.draw(batch, x, y)
370
401
                end
371
402
        end,
372
403
 
373
404
        -- makes sure all sprites receive startFrame messages
374
405
 
375
406
        startFrame = function (self, elapsed)
376
 
                for _, spr in pairs(self.sprites) do
 
407
                for _, spr in self:members() do
377
408
                        spr:startFrame(elapsed)
378
409
                end
379
410
 
383
414
        -- makes sure all sprites receive update messages
384
415
 
385
416
        update = function (self, elapsed)
386
 
                for _, spr in pairs(self.sprites) do
 
417
                for _, spr in self:members() do
387
418
                        spr:update(elapsed)
388
419
                end
389
420
 
393
424
        -- makes sure all sprites receive endFrame messages
394
425
 
395
426
        endFrame = function (self, elapsed)
396
 
                for _, spr in pairs(self.sprites) do
 
427
                for _, spr in self:members() do
397
428
                        spr:endFrame(elapsed)
398
429
                end
399
430
 
400
431
                Sprite.endFrame(self, elapsed)
401
432
        end,
402
433
 
 
434
        -- mimic Group's members() method
 
435
 
 
436
        members = function (self)
 
437
                return ipairs(self.sprites)
 
438
        end,
 
439
 
403
440
        __tostring = function (self)
404
 
                local result = 'Map (x: ' .. self.x .. ', y: ' .. self.y ..
405
 
                                           ', w: ' .. self.width .. ', h: ' .. self.height .. ', '
 
441
                local result = 'Map (x: ' .. tostring(self.x) .. ', y: ' .. tostring(self.y) ..
 
442
                                           ', w: ' .. tostring(self.width) .. ', h: ' .. tostring(self.height) .. ', '
406
443
 
407
444
                if self.active then
408
445
                        result = result .. 'active, '