/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: 2013-08-24 21:15:46 UTC
  • Revision ID: josh@9ix.org-20130824211546-713om9pp99jgd6of
more map

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
 
 
36
30
        -- Method: empty
37
31
        -- Creates an empty map.
38
32
        --
345
339
                -- determine drawing bounds
346
340
                -- we draw to fill the entire app windoow
347
341
                
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 })
 
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] = {}
385
356
                                        end
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)
 
357
                                        
 
358
                                        table.insert(toDraw[sprite], { x + (drawX - 1) * self.spriteWidth,
 
359
                                                                                                   y + (drawY - 1) * self.spriteHeight })
394
360
                                end
395
361
                        end
396
362
                end
397
 
 
398
 
                for _, batch in pairs(self.spriteBatches) do
399
 
                        --batch:unbind()
400
 
                        love.graphics.draw(batch, x, y)
 
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
401
370
                end
402
371
        end,
403
372
 
404
373
        -- makes sure all sprites receive startFrame messages
405
374
 
406
375
        startFrame = function (self, elapsed)
407
 
                for _, spr in self:members() do
 
376
                for _, spr in pairs(self.sprites) do
408
377
                        spr:startFrame(elapsed)
409
378
                end
410
379
 
414
383
        -- makes sure all sprites receive update messages
415
384
 
416
385
        update = function (self, elapsed)
417
 
                for _, spr in self:members() do
 
386
                for _, spr in pairs(self.sprites) do
418
387
                        spr:update(elapsed)
419
388
                end
420
389
 
424
393
        -- makes sure all sprites receive endFrame messages
425
394
 
426
395
        endFrame = function (self, elapsed)
427
 
                for _, spr in self:members() do
 
396
                for _, spr in pairs(self.sprites) do
428
397
                        spr:endFrame(elapsed)
429
398
                end
430
399
 
431
400
                Sprite.endFrame(self, elapsed)
432
401
        end,
433
402
 
434
 
        -- mimic Group's members() method
435
 
 
436
 
        members = function (self)
437
 
                return ipairs(self.sprites)
438
 
        end,
439
 
 
440
403
        __tostring = function (self)
441
 
                local result = 'Map (x: ' .. tostring(self.x) .. ', y: ' .. tostring(self.y) ..
442
 
                                           ', w: ' .. tostring(self.width) .. ', h: ' .. tostring(self.height) .. ', '
 
404
                local result = 'Map (x: ' .. self.x .. ', y: ' .. self.y ..
 
405
                                           ', w: ' .. self.width .. ', h: ' .. self.height .. ', '
443
406
 
444
407
                if self.active then
445
408
                        result = result .. 'active, '