Formatting

* Rename trigger state to match convention

Core/baseClasses/base_effect.py

@@ -1,10 +1,6 @@
 from core.enums.caverna_enums import TriggerStateEnum
 
-class BaseEffect(object):
-    def __init__(self, triggerState = TriggerStateEnum.UserChoice):
-        self._triggerState = triggerState
 
-    def invoke(
-        self,
-        player ) -> bool:
-        raise NotImplementedError("abstract base effect class")
+class BaseEffect(object):
+    def __init__(self, trigger_state=TriggerStateEnum.UserChoice):
+        self._triggerState = trigger_state

buisness_logic/__init__.py

@@ -1,5 +1,5 @@
 __all__ = [
-"actions",
-"cards",
-"effects",
-"tiles" ]
+    "actions",
+    "cards",
+    "effects",
+    "tiles"]

buisness_logic/effects/__init__.py

@@ -1,8 +1,9 @@
 __all__ = [
-"animal_storage_effects",
-"board_effects",
-"conversion_effects",
-"population_effects",
-"purchase_effects",
-"resource_effects",
-]
+    "action_effects",
+    "animal_storage_effects",
+    "board_effects",
+    "conversion_effects",
+    "population_effects",
+    "purchase_effects",
+    "resource_effects",
+]

buisness_logic/effects/board_effects.py

@@ -3,38 +3,43 @@
 from core.enums.caverna_enums import TileTypeEnum
 from common.defaults.tile_twin_default import TileTwinDefault
 
+
 class BaseBoardEffect(BaseEffect):
-    def Invoke(self, source: Dict[TileTypeEnum, List[TileTypeEnum]]) -> Dict[TileTypeEnum, List[TileTypeEnum]]:
-        raise NotImplementedException("base board effect class")
+    def invoke(self, source: Dict[TileTypeEnum, List[TileTypeEnum]]) -> Dict[TileTypeEnum, List[TileTypeEnum]]:
+        raise NotImplementedError("base board effect class")
+
 
 class ChangeRequisiteEffect(BaseBoardEffect):
-    def __init__(self, tiles: List[TileTypeEnum], newRequisites: List[TileTypeEnum]):
+    def __init__(self, tiles: List[TileTypeEnum], new_requisites: List[TileTypeEnum]):
         if tiles is None:
             raise ValueError()
-        if newRequisites is None:
+        if new_requisites is None:
             raise ValueError()
-            
+
         self._tiles: List[TileTypeEnum] = tiles
-        self._newRequisites: List[TileTypeEnum] = newRequisites
-
-    def Invoke(self, source: Dict[TileTypeEnum, List[TileTypeEnum]]) -> Dict[TileTypeEnum, List[TileTypeEnum]]:
+        self._newRequisites: List[TileTypeEnum] = new_requisites
+        super().__init__()
+
+    def invoke(self, source: Dict[TileTypeEnum, List[TileTypeEnum]]) -> Dict[TileTypeEnum, List[TileTypeEnum]]:
         if source is None:
             raise ValueError()
-        
+
         for tile in self._tiles:
             source[tile].extend(self._newRequisites)
         return source
 
+
 class FurnishTunnelsEffect(ChangeRequisiteEffect):
     def __init__(self):
         super().__init__(
-            [TileTypeEnum.furnishedCavern, TileTypeEnum.furnishedDwelling], 
-            [TileTypeEnum.tunnel, TileTypeEnum.deepTunnel] )
-
+            [TileTypeEnum.furnishedCavern, TileTypeEnum.furnishedDwelling],
+            [TileTypeEnum.tunnel, TileTypeEnum.deepTunnel])
+
+
 class TwinTilesOverhangEffect(ChangeRequisiteEffect):
     def __init__(self):
-        twinDefault = TileTwinDefault.TileTwinDefault()
-        twinTiles = twinDefault.Assign( [] )
+        twin_default = TileTwinDefault()
+        twin_tiles = twin_default.assign([])
         super().__init__(
-            twinTiles,
-            [TileTypeEnum.unavailable] )
+            twin_tiles,
+            [TileTypeEnum.unavailable])

buisness_logic/effects/population_effects.py

@@ -1,17 +1,20 @@
 from common.entities.player import Player
 from core.baseClasses.base_effect import BaseEffect
 
+
 class BasePopulationEffect(BaseEffect):
     def Invoke(self, player: Player) -> bool:
-        raise NotImplementedException("base population effect class")
-
+        raise NotImplementedError("base population effect class")
+
+
 class IncreasePopulationCapEffect(BasePopulationEffect):
-    def __init__(self, increaseBy: int):
-        self._increaseBy = increaseBy
+    def __init__(self, increase_by: int):
+        self._increaseBy = increase_by
 
     def Invoke(self, player: Player) -> bool:
-        raise NotImplementedException()
-
+        raise NotImplementedError()
+
+
 class AllowSixthDwarfEffect(BasePopulationEffect):
     def Invoke(self, player: Player) -> bool:
-        raise NotImplementedException()
+        raise NotImplementedError()

buisness_logic/effects/resource_effects.py

@@ -11,11 +11,11 @@ def __init__(self, output):
         self._output = output
 
 class ReceiveConditional(BaseResourceEffect):
-    def __init__(self, input, condition, triggerState:  TriggerStateEnum = TriggerStateEnum.StartOfTurn):
+    def __init__(self, input, condition, trigger_state:  TriggerStateEnum = TriggerStateEnum.StartOfTurn):
         """Recieve some input when some condition is true."""
         self._input = input
         self._condition = condition
-        super().__init__(triggerState)
+        super().__init__(trigger_state)
 
     def invoke(self, player):
         numberOfTimesConditionMet = self._condition(player)
@@ -26,11 +26,11 @@ def invoke(self, player):
         return True
 
 class ReceiveProportional(BaseResourceEffect):
-    def __init__(self, input, proportionalTo, triggerState:  TriggerStateEnum = TriggerStateEnum.StartOfTurn):
+    def __init__(self, input, proportionalTo, trigger_state:  TriggerStateEnum = TriggerStateEnum.StartOfTurn):
         """Recieve some x input per x "proportionalTo"."""
         self._input = input
         self._proportionalTo = proportionalTo
-        super().__init__(triggerState)
+        super().__init__(trigger_state)
 
     def invoke(self, player):
         playerResources = player.get_resources()