def testToCoordinatesSimple(self):
values: str = '5,5'
actualCoordinates: Coordinates = Coordinates.toCoordinates(
values=values)
expectedCoordinates: Coordinates = Coordinates(5, 5)
self.assertEqual(expectedCoordinates, actualCoordinates,
'Did not get appropriate coordinates')
def testComputeQuadrantDistanceSmall(self):
startSectorCoordinates = Coordinates(4, 2)
endSectorCoordinates = Coordinates(4, 8)
self.logger.info(f"Small distance sector coordinates {startSectorCoordinates}, {endSectorCoordinates}")
distance = self.smarty.computeQuadrantDistance(startSector=startSectorCoordinates, endSector=endSectorCoordinates)
self.logger.info(f"West/East distance is: {distance}")
def testNewCoordinatesSouthWest(self):
coordinates = Coordinates(STANDARD_X_COORDINATE, STANDARD_Y_COORDINATE)
newCoordinate = coordinates.newCoordinates(Direction.SouthWest)
self.assertEqual(newCoordinate.x, EXPECTED_X_COORDINATE_SW_MOVEMENT,
"Should have decremented 'x'")
self.assertEqual(newCoordinate.y, EXPECTED_Y_COORDINATE_SW_MOVEMENT,
"Should have incremented 'y'")
def testDoPhasersShortDistance(self):
shooterCoordinates: Coordinates = Coordinates(0, 4)
targetCoordinates: Coordinates = Coordinates(4, 4)
expectedPhaserHit: float = 239.68
self._runPhaserTest(shooterCoordinates=shooterCoordinates,
targetCoordinates=targetCoordinates,
expectedPhaserHit=expectedPhaserHit)
def testShipAdjacentToBaseNotAdjacentClose(self):
shipPosition: Coordinates = Coordinates(x=7, y=7)
basePosition: Coordinates = Coordinates(x=5, y=5)
adjacent: bool = self._gameEngine.shipAdjacentToBase(
shipPosition=shipPosition, basePosition=basePosition)
self.assertFalse(adjacent, 'We are pretty close but not adjacent')
def testComputeCourseDiagonal(self):
start: Coordinates = Coordinates(x=0, y=0)
end: Coordinates = Coordinates(x=9, y=9)
course: float = self._gameEngine._computeCourse(start=start, end=end)
angle: float = degrees(course)
self.assertEqual(45, angle, 'Busted code')
self.logger.info(f'{course=} {angle=}')
def testShipAdjacentToBaseNotAdjacentVeryFar(self):
shipPosition: Coordinates = Coordinates(x=9, y=9)
basePosition: Coordinates = Coordinates(x=5, y=5)
adjacent: bool = self._gameEngine.shipAdjacentToBase(
shipPosition=shipPosition, basePosition=basePosition)
self.assertFalse(adjacent, 'We are very far and not adjacent')
def testDoPhasersMaxDistance(self):
shooterCoordinates: Coordinates = Coordinates(0, 0)
targetCoordinates: Coordinates = Coordinates(9, 9)
expectedPhaserHit: float = 218.6
self._runPhaserTest(shooterCoordinates=shooterCoordinates,
targetCoordinates=targetCoordinates,
expectedPhaserHit=expectedPhaserHit)
def testComputeCourseStraightWest(self):
end: Coordinates = Coordinates(x=0, y=5)
start: Coordinates = Coordinates(x=9, y=5)
course: float = self._gameEngine._computeCourse(start=start, end=end)
angle: float = degrees(course)
self.assertEqual(180, angle, 'Did calculation chang')
self.logger.info(f'{course=} {angle=}')
def testShipAdjacentToBaseSouthWest(self):
shipPosition: Coordinates = Coordinates(x=6, y=4)
basePosition: Coordinates = Coordinates(x=5, y=5)
adjacent: bool = self._gameEngine.shipAdjacentToBase(
shipPosition=shipPosition, basePosition=basePosition)
self.assertTrue(adjacent, 'We are directly SouthWest')
def testComputeCourseUp(self):
start: Coordinates = Coordinates(x=0, y=0)
end: Coordinates = Coordinates(x=0, y=9)
backwardCourse: float = self._gameEngine._computeCourse(start=end,
end=start)
backAngle: float = degrees(backwardCourse)
self.assertEqual(-90, backAngle, 'Who changed my code')
self.logger.info(f'{backwardCourse=} {backAngle=}')
def testComputeCourseDown(self):
start: Coordinates = Coordinates(x=0, y=0)
end: Coordinates = Coordinates(x=0, y=9)
course: float = self._gameEngine._computeCourse(start=start, end=end)
downAngle: float = degrees(course)
self.assertEqual(90, downAngle, 'Hmm, messed up code')
self.logger.info(f'{course=} {downAngle=}')
def testToCoordinatesInvalidY(self):
invalidY: int = MAX_SECTOR_Y_COORDINATE + 1
values: str = f'5,{invalidY}'
actualCoordinates: Coordinates = Coordinates.toCoordinates(
values=values)
expectedCoordinates: Coordinates = Coordinates(0, 0)
self.assertEqual(expectedCoordinates, actualCoordinates,
'Did not detect invalid Y')
def testComputeQuadrantDistanceBottomRightToTopLeft(self):
"""
"""
startSectorCoordinates = Coordinates(MAX_SECTOR_X_COORDINATE, MAX_SECTOR_Y_COORDINATE)
endSectorCoordinates = Coordinates(MIN_SECTOR_X_COORDINATE, MIN_SECTOR_Y_COORDINATE)
distance = self.smarty.computeQuadrantDistance(startSector=startSectorCoordinates, endSector=endSectorCoordinates)
self.logger.info(f"Reverse Max distance is: {distance}")
self.assertGreater(distance, TestComputer.MIN_QUADRANT_DISTANCE, "Max distance calculation failed less than zero")
self.assertGreaterEqual(distance, TestComputer.MAX_QUADRANT_DIAGONAL_DISTANCE, "Incorrect reverse max distance")
def testComputeQuadrantDistanceWestToEast(self):
""""""
startSectorCoordinates = Coordinates(MAX_SECTOR_X_COORDINATE, MAX_SECTOR_Y_COORDINATE // 2)
endSectorCoordinates = Coordinates(MIN_SECTOR_X_COORDINATE, MAX_SECTOR_Y_COORDINATE // 2)
self.logger.info("Quadrant West to East sector coordinates %s, %s ", startSectorCoordinates, endSectorCoordinates)
distance = self.smarty.computeQuadrantDistance(startSector=startSectorCoordinates, endSector=endSectorCoordinates)
self.logger.info("West/East distance is: %s", distance)
self.assertGreater(distance, TestComputer.MIN_QUADRANT_DISTANCE, "East/West calculation failed less than zero")
self.assertEqual(distance, TestComputer.MAX_QUADRANT_PERPENDICULAR_DISTANCE, "Incorrect East/West distance")
def testShipAdjacentToBaseNorth(self):
"""
In these tests the base is always at sector coordinates 5,5
"""
shipPosition: Coordinates = Coordinates(x=4, y=5)
basePosition: Coordinates = Coordinates(x=5, y=5)
adjacent: bool = self._gameEngine.shipAdjacentToBase(
shipPosition=shipPosition, basePosition=basePosition)
self.assertTrue(adjacent, 'We are directly north')
def _commonComputeHit(self, playerType: PlayerType) -> float:
self._gameState.playerType = playerType
shooterPosition: Coordinates = Coordinates(x=7, y=7)
targetPosition: Coordinates = Coordinates(x=3, y=7)
klingonPower: float = 348.0
computedHit = self._gameEngine.computeHit(
shooterPosition=shooterPosition,
targetPosition=targetPosition,
klingonPower=klingonPower)
return computedHit
def testComputeEnergyWhenBlockedMinimum(self):
startSector: Coordinates = Coordinates(x=1, y=1)
endSector: Coordinates = Coordinates(x=1, y=2)
expectedStopEnergy: float = 30.0
decimalPlace: int = 2
stopEnergy: float = self._gameEngine.computeEnergyWhenBlocked(
startSector=startSector, endSector=endSector)
self.logger.info(f'{stopEnergy}')
self.assertAlmostEqual(expectedStopEnergy, stopEnergy, decimalPlace,
'Minimum test does not compute')
def createTractorBeamEvent(self) -> FutureEvent:
# noinspection SpellCheckingInspection
"""
```java
schedule(FTBEAM, tk.expran(1.5 * (game.intime / game.state.remcom)));
```
"""
inTime: float = self._gameState.inTime
remainingCommanders: int = self._gameState.remainingCommanders
if remainingCommanders == 0:
futureEvent: FutureEvent = FutureEvent(
type=FutureEventType.TRACTOR_BEAM,
starDate=0.0,
quadrantCoordinates=Coordinates(x=-1, y=-1))
futureEvent.schedulable = False
else:
elapsedStarDates: float = self._intelligence.exponentialRandom(
2.5 * (inTime / remainingCommanders))
eventStarDate: float = self._gameState.starDate + elapsedStarDates
coordinates: Coordinates = self._gameState.currentQuadrantCoordinates
futureEvent = FutureEvent(type=FutureEventType.TRACTOR_BEAM,
starDate=eventStarDate,
quadrantCoordinates=coordinates)
futureEvent.callback = EventCallback(
self._futureEventHandlers.tractorBeamEventHandler)
return futureEvent
def testComputeGalacticDistanceWestToEast(self):
"""
Not going to retest distance computations between inter-quadrant and galactic travel
as galactic is just 10 times more expensive
"""
startQuadrantCoordinates = Coordinates(MAX_QUADRANT_X_COORDINATE, floor(MAX_QUADRANT_Y_COORDINATE // 2))
endQuadrantCoordinates = Coordinates(MIN_QUADRANT_X_COORDINATE, floor(MAX_QUADRANT_Y_COORDINATE // 2))
self.logger.info(f"West to East quadrant coordinates {startQuadrantCoordinates}, {endQuadrantCoordinates}")
distance = self.smarty.computeGalacticDistance(startQuadrantCoordinates=startQuadrantCoordinates, endQuadrantCoordinates=endQuadrantCoordinates)
self.logger.info(f"Galactic West/East distance is: {distance}")
self.assertGreater(distance, TestComputer.MIN_GALACTIC_DISTANCE, "East/West calculation failed less than zero")
self.assertEqual(distance, TestComputer.MAX_GALACTIC_DISTANCE, "Incorrect East/West distance")
def _updateQuadrant(self, quadrant):
for y in range(QUADRANT_ROWS):
for x in range(QUADRANT_COLUMNS):
sector: Sector = quadrant.getSector(Coordinates(x, y))
self.logger.debug(f'{sector}')
gamePiece: GamePiece = sector.sprite
sectorType: SectorType = sector.type
if sectorType != SectorType.EMPTY:
if sectorType == SectorType.KLINGON:
self._km.update(quadrant=quadrant,
klingon=cast(Klingon, gamePiece))
elif self._noUpdateSector(sectorType=sectorType) is True:
pass
elif sectorType == SectorType.COMMANDER:
self._cm.update(quadrant=quadrant,
commander=cast(Commander, gamePiece))
elif sectorType == sectorType.SUPER_COMMANDER:
self._scm.update(quadrant=quadrant,
superCommander=cast(
SuperCommander, gamePiece))
else:
assert False, 'Bad Game Piece'
def draw(self, centerCoordinates: Coordinates):
for y in range(GALAXY_ROWS):
for x in range(GALAXY_COLUMNS):
coordinates: Coordinates = Coordinates(x=x, y=y)
quadrant: Quadrant = self._galaxy.getQuadrant(
quadrantCoordinates=coordinates)
if quadrant.scanned is True:
if centerCoordinates == coordinates:
contents: str = 'E'
arcadePoint: ArcadePoint = Computer.gamePositionToScreenPoint(
coordinates)
arcadeX: float = arcadePoint.x + 2
arcadeY: float = arcadePoint.y + 2
else:
contents = self._computer.createValueString(
klingonCount=quadrant.klingonCount,
commanderCount=quadrant.commanderCount,
hasStarBase=quadrant.hasStarBase)
arcadePoint = Computer.gamePositionToScreenPoint(
coordinates)
arcadeX = arcadePoint.x
arcadeY = arcadePoint.y
draw_text(contents, arcadeX, arcadeY, color.WHITE, 14)
def _makeGamePiecePalette(self):
"""
These are the static icons that can be dragged on screen
"""
bogusCoordinates: Coordinates = Coordinates(-1, -1)
paletteKlingon: Klingon = Klingon(coordinates=bogusCoordinates)
paletteKlingon.id = TestShooting.PALETTE_KLINGON_ID
paletteKlingon.center_x = 32
paletteKlingon.center_y = 150
paletteCommander: Commander = Commander(coordinates=bogusCoordinates,
moveInterval=-1)
paletteCommander.id = TestShooting.PALETTE_COMMANDER_ID
paletteCommander.center_x = paletteKlingon.center_x + 64
paletteCommander.center_y = 150
paletteSuperCommander: SuperCommander = SuperCommander(
coordinates=bogusCoordinates, moveInterval=-1)
paletteSuperCommander.id = TestShooting.PALETTE_SUPER_COMMANDER_ID
paletteSuperCommander.center_x = paletteCommander.center_x + 64
paletteSuperCommander.center_y = 150
self._staticSprites.append(paletteKlingon)
self._staticSprites.append(paletteCommander)
self._staticSprites.append(paletteSuperCommander)
class WarpTravelAnswer:
"""
The `course` and `distance` values are only valid when dialogAnswer is DialogAnswer.Ok
"""
dialogAnswer: DialogAnswer = DialogAnswer.Cancelled
coordinates: Coordinates = Coordinates(x=-1, y=-1)
warpFactor: float = 0.0
class Sector:
sprite: GamePiece = cast(GamePiece, None)
type: SectorType = SectorType.EMPTY
coordinates: Coordinates = Coordinates(0, 0)
def __str__(self) -> str:
return f"SectorType: {str(self.type)} Coordinates: {self.coordinates}"
def testHitThem(self):
shooterCoordinates: Coordinates = Coordinates(0, 0)
targetCoordinates: Coordinates = Coordinates(9, 9)
distance: float = self._computer.computeQuadrantDistance(
startSector=shooterCoordinates, endSector=targetCoordinates)
enemyPower: float = 500.0
powerDrain: float = self._gameEngine.hitThem(distance=distance,
hit=218.6,
enemyPower=enemyPower)
minPowerDrain: float = 329
self.assertGreater(powerDrain, minPowerDrain,
'Did not calculate the minimum power drain')
self.logger.info(f'{powerDrain=}')
def generateQuadrantCoordinates(self) -> Coordinates:
"""
Generate a random set of quadrant coordinates
"""
x = randrange(GALAXY_COLUMNS)
y = randrange(GALAXY_ROWS)
return Coordinates(x, y)
def generateSectorCoordinates(self) -> Coordinates:
"""
Generate a random set of sector coordinates
"""
x = randrange(QUADRANT_COLUMNS)
y = randrange(QUADRANT_ROWS)
return Coordinates(x=x, y=y)
class LRScanCoordinates:
"""
This data object classifies coordinates for the method Intelligence.generateAdjacentCoordinates.
It indicates the coordinate value and the direction from the center quadrant; Aka,
here the Enterprise is located
"""
coordinates: Coordinates = Coordinates(x=0, y=0)
direction: Direction = Direction.North
def testGetRandomSectorCoordinates(self):
""""""
coordinates: Coordinates = self.smarty.generateSectorCoordinates()
self.assertIsNotNone(coordinates, "Should not be null")
self.logger.info("random coordinates: '%s'", coordinates)
bogusCoordinate = Coordinates(-1, -1)
self.assertNotEqual(coordinates, bogusCoordinate,
"Not truly initializing random coordinates")