# This file is part of ROBOTGAME
#
# ROBOTGAME 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 3 of the License, or (at your option) any later
# version.
#
# ROBOTGAME is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# ROBOTGAME.  If not, see <http://www.gnu.org/licenses/>.
#
# ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '
#
#                        worldobject.py
#                     --------------------
#       date created : Tue Aug 7 2012
#          copyright : (C) 2012 Sakse Dalum
#      maintained by : Sakse Dalum <don_s@hongabar.org>

"""
A generic world object.
"""

import pygame
import numpy
import copy

class WorldObject(object):
    def __init__(self, level, x, y, z=0, direction=(1, 0), speed=4,
                 tile_x=64, tile_y=48,
                 movable=False, blocking=True, is_moving=False, visible=True):
        self.__dict__.update(locals())

        self.init_x = self.move_x = self.x = x - (x % self.tile_x)
        self.init_y = self.move_y = self.y = y - (y % self.tile_y)
        self.init_direction = self.direction

        self.holding = None
        self.holder = None

        self.is_currently_opaque = True

        if hasattr(self, 'img'):
            self.img = copy.copy(self.img)

    def set_pos(self, x, y):
        self.move_x = self.x = x - (x % self.tile_x)
        self.move_y = self.y = y - (y % self.tile_y)

    def set_init_pos(self):
        self.init_x, self.init_y = self.x, self.y
        self.init_direction = self.direction

    def reset_pos(self):
        self.x, self.y = self.move_x, self.move_y = self.init_x, self.init_y
        self.direction = self.init_direction

    def share_tile(self, obj_type):
        for obj in self.level.objects:
            if (obj.x - (obj.x % self.tile_x) == self.x - (self.x % self.tile_x)
                and obj.y - (obj.y % self.tile_y) == self.y - (self.y
                                                               % self.tile_y)
                and obj is not self and isinstance(obj, obj_type)):
                return obj
        return None

    def check_move(self, move_x, move_y):
        if self.move_x == self.x and self.move_y == self.y and self.movable:
            for obj in self.level.objects:
                if (obj.x == self.x + move_x * self.tile_x
                    and obj.y == self.y + move_y * self.tile_y
                    and obj is not self and obj is not self.holder
                    and obj is not self.holding and obj.blocking):
                    return False
            return True
        return False

    def move(self, move_x, move_y):
        if self.check_move(move_x, move_y):

            if self.holding:
                if not self.holding.check_move(move_x, move_y):
                    return False

            self.move_x += move_x * self.tile_x
            self.move_y += move_y * self.tile_y

            if self.holding:
                self.holding.move(move_x, move_y)

            return True
        return False

    def use(self, obj):
        pass

    def activate(self, setting):
        pass

    def update_alpha(self):
        pass

    def set_alpha(self, value):
        """
        Set the relative translucency of the per-pixel-alpha image.

        Value between 0 - 1, where 0 is completely transparent and 1 is
        completely opaque.
        """
        if hasattr(self, 'img') and hasattr(self, 'orig_alpha'):
            alpha = pygame.surfarray.pixels_alpha(self.img)
            alpha[:] = (self.orig_alpha * value).astype(numpy.uint8)

    def update(self, e, t, dt):
        if self.x > self.move_x:
            self.x -= min(self.speed * dt * self.tile_x,
                          abs(self.x - self.move_x))
        if self.x < self.move_x:
            self.x += min(self.speed * dt * self.tile_x,
                          abs(self.x - self.move_x))
        if self.y > self.move_y:
            self.y -= min(self.speed * dt * self.tile_y,
                          abs(self.y - self.move_y))
        if self.y < self.move_y:
            self.y += min(self.speed * dt * self.tile_y,
                          abs(self.y - self.move_y))

        self.is_moving = self.x != self.move_x or self.y != self.move_y

        self.x, self.y = int(self.x), int(self.y)