game.py

__author__ = 'archheretic'

from kivy.uix.widget import Widget
from kivy.clock import Clock
from kivy.uix.image import Image


from kivy.properties import NumericProperty, ReferenceListProperty, BooleanProperty, ObjectProperty, ListProperty
from kivy.atlas import Atlas
from kivy.config import Config
from kivy.vector import Vector
from kivy.core.window import Window
from kivy.uix.screenmanager import Screen


from storagelayer import SaveStorage

#will be refactored later on:

class Background(Widget):
    image_one = ObjectProperty(Image())
    image_two = ObjectProperty(Image())

    velocity_x = NumericProperty(0)
    velocity_y = NumericProperty(0)
    velocity = ReferenceListProperty(velocity_x, velocity_y)

    def update(self):
        self.image_one.pos = Vector(*self.velocity) + self.image_one.pos
        self.image_two.pos = Vector(*self.velocity) + self.image_two.pos

        if self.image_one.right <= 0:
            self.image_one.pos = (self.width, 0)
        if self.image_two.right <= 0:
            self.image_two.pos = (self.width, 0)

    def update_position(self):
        self.image_one.pos = (0, 0)
        self.image_two.pos = (self.width, 0)


class Player(Widget):
    """
    Hele denne klassen ma skrives om seinere, dette er bare en hybrid mellom
    spillets prototype og en eksempel kode.
    """
    atlas = Atlas("data/characters/player/player.atlas")


    player_image = ObjectProperty(Image())

    jump_time = NumericProperty(0.3)
    jump_height = NumericProperty(95)

    time_jumped = NumericProperty(0)

    jumping = BooleanProperty(False)

    velocity_x = NumericProperty(0)
    velocity_y = NumericProperty(0)
    normal_velocity_x = NumericProperty(0)
    normal_velocity_y = NumericProperty(0)
    velocity = ReferenceListProperty(velocity_x, velocity_y)
    normal_velocity = ReferenceListProperty(normal_velocity_x, normal_velocity_y)

    def __init__(self, **kwargs):
        super(Player, self).__init__(**kwargs)
        if Config.getdefault("input", "keyboard", False):
            self._keyboard = Window.request_keyboard(
                self._keyboard_closes, self, "text")
            self._keyboard.bind(on_key_down=self._on_keyboard_down)

    def _keyboard_closed(self):
        self._keyboard.unbind(on_key_down=self._on_keyboard_down)

    def switch_to_normal(self, dt):
        #self.player_image.source = self.atlas["playeratlas-0.png"]["player_up_1"]#opp
        self.player_image.source = "atlas://data/characters/player/player/player_up_1"
        Clock.schedule_once(self.stop_jumping, self.jump_time * (4.0 / 5.0))

    def stop_jumping(self, dt):
        self.jumping = False
        self.player_image.source = "atlas://data/characters/player/player/player_down_5" #ned
        self.velocity_y = self.normal_velocity_y

    def on_touch_down(self, touch):
        self.jumping = True
        self.player_image.source = "atlas://data/characters/player/player/player_right_2" # normal idle
        self.velocity_y = self.jump_height / (self.jump_time * 60.0)
        Clock.unschedule(self.stop_jumping)
        Clock.schedule_once(self.switch_to_normal, self.jump_time / 5.0)

    def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
        self.on_touch_down(None)

    def update(self):
        self.pos = Vector(*self.velocity) + self.pos
        if self.pos[1] <= 104:
            Clock. unschedule(self.stop_jumping)
            self.player_image.source = "atlas://data/characters/player/player/player_right_2" # normal idle
            self.pos = (self.pos[0], 104)



class Game(Screen):
    player = ObjectProperty(Player())
    background = ObjectProperty(Background())

    def on_enter(self):
        # In the game only background will have velocity.
        self.player.normal_velocity = [0, -4]
        self.player.velocity = self.player.normal_velocity

        self.background.velocity = [-2, 0]
        self.bind(size=self.size_callback)

        Clock.schedule_interval(self.update, 1.0 / 60.0)

    def size_callback(self, instance, value):
        self.background.size = value
        self.background.update_position()

    def update(self, dt):
        self.player.update()
        self.background.update()


class InitiateGame(Screen):

    def on_enter(self):
        game = Game()
        #game.set_save(save_name)
        #if is_new_game:
        #    game.new_game()
        #else:
        #    game.load_game()
        Clock.schedule_interval(game.update, 1.0 / 60.0)
        return game


    def new_game(self):
        pass

    def load_game(self):
        SaveStorage.get_save(get_save_name())

    def set_save_name(self, save_name):
        pass
    def get_save_name(self):
        pass

"""
FRom former js game

    var imageWidth = 576;
    var imageHeight = 256;
    var tileWidth = 64;
    var tileHeight = 64;
    //numberOfFramesX = 9;
    //numberOfFramesY = 4;

    var tilesX = imageWidth / tileWidth;
    var tilesY = imageHeight / tileHeight;

    var totalTiles = tilesX * tilesY;
    for(var i=0; i<tilesY; i++) {
        for(var j=0; j<tilesX; j++) {
        // Store the image data of each tile in the array.
        playerTileData.push(ctx.getImageData(j*tileWidth, i*tileHeight, tileWidth, tileHeight));
        }
    }
    //From here you should be able to draw your images back into a canvas like so:

    ctx.clearRect(0, 0, canvas.width, canvas.height);
//    ctx.putImageData(playerTileData[20], 100, 768);

    playerImgReady = true;

}, false);

//playerImg.onload = function() {}
playerImg.src = "resources/images/professor_walk_cycle_no_hat.png";
"""