class Board(BaseModel):
board: Dict[int, House] = dict(
zip(list(range(1, 25)),
[House.build(house_number=i) for i in range(1, 25)]))
current_turn_toss: Sequence[int] = Field(default_factory=Dice.toss)
@property
def toss(self):
return self.current_turn_toss
def next(self, toss: Sequence[int] = None, number: int = 2) -> None:
self.current_turn_toss = toss or Dice.toss(number)
if self.current_turn_toss[0] == self.current_turn_toss[1]:
self.current_turn_toss *= 2
def board_items(self) -> ItemsView[int, House]:
return self.board.items()
def marble_houses(
self,
marble: Marble,
indexes_seq: bool = False) -> Sequence[Union[int, House]]:
result_sequence = []
for house_number, house in self.board_items():
if house.is_host(marble):
result_sequence.append(house_number if indexes_seq else house)
return result_sequence
def get_house(self, house: Union[House, int]) -> House:
return self[house]
def can_move(self,
src: Union[House, int],
dst: Union[House, int],
marble: Marble,
number: int = 1):
src, dst = self.get_house(src), self.get_house(dst)
return bool(src and dst and src.is_host(marble)
and src.marble_counter(marble) >= number
and marble.has_progressive_movements(int(src), int(dst))
and dst.can_add(marble))
def move_marble(self,
src: Union[House, int],
dst: Union[House, int],
marble: Marble,
number: int = 1) -> bool:
if not self.can_move(src, dst, marble, number):
return False
self.get_house(src).pop(marble, number)
self.get_house(dst).add(marble, number)
def move_by(self,
src: Union[House, int],
marble: Marble,
movements: int,
number: int = 1) -> bool:
return self.move_marble(src, marble.get_destination(src, movements),
marble, number)
@staticmethod
def __extract_slice(
slice: Union[slice,
int]) -> Sequence[int, Optional[int], Optional[int]]:
if not isinstance(slice, int):
return int(slice.start), \
int(slice.stop if slice.stop is not None else slice.start + 1), \
int(slice.step if slice.step is not None else 1)
return int(slice), None, None
@staticmethod
def __check_slice_indexes(start: int, end: Optional[int],
step: Optional[int]) -> bool:
has_end = bool(end)
has_step = bool(step)
return not 1 <= start <= 24 \
or has_end \
and not (
0 if has_step and step == -1 else 1
) <= end <= (
25 if has_step and step == 1 else 24
)
def __getitem__(self, slice: Union[slice, int]) -> House:
if isinstance(slice, House):
return slice
start, end, step = Board.__extract_slice(slice)
if self.__check_slice_indexes(start, end, step):
return None
if end is None or abs(start - end) == 1:
return self.board[start]
return [self.board[i] for i in range(start, end, step)]
def __eq__(self, other: Board):
return self.board == other.board
def __str__(self):
from algorithms.house import house_collection_to_string
board = self.copy()
above_houses = board[13:25]
down_houses = board[12:0:-1]
stream = house_collection_to_string(above_houses) \
+ '\n' \
+ house_collection_to_string(down_houses, reverse=True)
return stream
def __repr__(self):
return str(self)
def copy(self) -> Board:
return Board(**self.dict())
def __hash__(self):
return hash(tuple(self.board.values()))
import mcpi.minecraft as minecraft
import mcpi.block as block
import time
from song import Song
from model import Model
from house import House
mc=minecraft.Minecraft.create("127.0.0.3", 4711)
pos = mc.player.getTilePos()
house1 = House(mc,[pos.x, pos.y, pos.z])
house2 = House(mc,[pos.x+20, pos.y, pos.z])
house3 = House(mc,[pos.x+40, pos.y, pos.z])
house1.build()
house2.build()
house3.build()
model1 = Model(mc,'chiji.binvox')
model2 = Model(mc,'guidaopao.binvox')
model3 = Model(mc,'mickey__mouse_hoofd.binvox')
model1.build([pos.x, pos.y, pos.z+20])
model2.build([pos.x+20, pos.y, pos.z+20])
model3.build([pos.x+40, pos.y, pos.z+20])
song = Song()
while True:
pos = mc.player.getTilePos()
if house1.inHouse([pos.x, pos.y, pos.z]) or house3.inHouse([pos.x, pos.y, pos.z]):
song.run('我爱北京天安门')
print("Play song No.1")
