from typing import List, Tuple
from random import randint

class Robot:
    def __init__(self, name: str, place : List[int], start: Tuple[int, int] = (0,0), power: int = 100):
        self._name = name
        self._place = place
        self._start = start
        self._power = power

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if isinstance(value, str):
            self._name = value
        else:
            raise TypeError("must be a string")
    @property
    def place(self):
        return self._place

    @place.setter
    def place(self, value):
        if isinstance(value, list):
            self._start = value
        else:
            raise TypeError("must be a list")

    @property
    def start(self):
        return self._start

    @start.setter
    def start(self, value):
        if isinstance(value, tuple):
            self._start = value
        else:
            raise TypeError("must be a tuple")

    @property
    def power(self):
        return self._power

    @power.setter
    def power(self, value):
        if isinstance(value, int):
            self._start = value
        else:
            raise TypeError("must be a int")

    @property
    def check_power(self):
        if self._power <= 0:
            raise ValueError("No power")

    def left(self, value):
        # self.sprawdz_power()
        self.power -= value

        if self.place[0] - value < 0:
            self.place[0] = self.place[0] - value + 8

        else:
            self.place[0] = self.place[0] - value

    def up(self, value):
        # self.sprawdz_power()
        self.power -= value

        if self.place[1] + value > 7:
            self.place[1] = self.place[1] + value - 8

        else:
            self.place[1] = self.place[1] + value

        if self.place[1] == 5:
            self.power += 2

    def __str__(self):
        return "{} {} {}".format(self._name, self._place, self._power)

from itertools import combinations

def game_round(robots):
    losers = set()
    for a, b in combinations(robots, 2):
        if a.place == b.place:
            loser, winner = sorted([a, b], key=lambda robot: robot.power)
            winner.power += loser.power
            losers.add(loser)
            print(f'Robot {loser.name} has been slain by {winner.name}')

    return [robot for robot in robots if robot not in losers]



def game(number):
    for _ in range(number):

        if len(robots) == 1:
            print(robots[0].name, "is victorious")
            break

        to_delete = []
        for r_nr in range(len(robots)):
            strona_rand = randint(0,1)
            ruch_value = randint(0,4)


            if strona_rand == 0:
                try:
                    robots[r_nr].up(ruch_value)
                except:
                    to_delete.append(r_nr)

            elif strona_rand == 1:
                try:
                    robots[r_nr].left(ruch_value)
                except:
                    to_delete.append(r_nr)

        for r_nr in sorted(to_delete, reverse=True):
            print(f'Robot {robots[r_nr].name} lost all the power')
            del robots[r_nr]


robots = [
    Robot(name = "A", place = [3,4], start = (0,0), power = 100),
    Robot(name = "B", place = [1,2], start = (0,0), power = 100),
    Robot(name = "C", place = [1,2], start = (0,0), power = 100),
    Robot(name = "D", place = [1,2], start = (0,0), power = 100),
    Robot(name = "E", place = [1,2], start = (0,0), power = 100),
]


robots = game_round(robots)
game(100)


Robot B has been slain by C
Robot B has been slain by D
Robot B has been slain by E
Robot C has been slain by D
Robot C has been slain by E
Robot D has been slain by E