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")