예제 #1
0
파일: stats.py 프로젝트: rrpg/engine
	def render(self, data):
		output = list()
		statsLabels = {
			'stat_hp': _('STAT_CURRENT_HP'),
			'stat_attack': _('STAT_ATTACK'),
			'stat_defence': _('STAT_DEFENCE'),
			'stat_speed': _('STAT_SPEED'),
			'stat_luck': _('STAT_LUCK')
		}
		longestStat = max({len(stat): stat for stat in statsLabels.values()})

		# Display the health
		healthStat = '{0} / {1}'.format(
			stats.padStat(data['stat_current_hp'], 4),
			data['stat_max_hp']
		)
		lenHealthStat = len(healthStat)

		output.append(stats.formatStat(
			statsLabels['stat_hp'],
			longestStat,
			healthStat
		))

		# The remaining stats
		for i in data:
			if i != 'stat_current_hp' and i != 'stat_max_hp':
				output.append(stats.formatStat(
					statsLabels[i],
					longestStat,
					stats.padStat(data[i], lenHealthStat)
				))

		return '\n'.join(output)
예제 #2
0
파일: testLook.py 프로젝트: rrpg/engine
	def test_containers_text(self):
		self.rpg.setAction([_('LOOK_COMMAND'), _('LOOK_CONTAINERS_PARAM')])
		output = self.rpg._runAction()
		self.assertEquals(output, _('AVAILABLE_ITEMS_CONTAINERS') +'\n'+\
			'    chest #1\n' +\
			'    wardrobe #1\n' +\
			'    wardrobe #2')
예제 #3
0
	def openMap(self):
		"""
		Method to open a map from a filename
		"""
		fileName = self._app.getMapFileName() + '.bmp'

		image = QtGui.QImage(fileName)
		if image is None or imghdr.what(str(fileName)) != "bmp":
			QtGui.QMessageBox.information(
				self,
				_('IMAGE_VIEWER'),
				_('ERROR_OPEN_%s') % (fileName)
			)
			return

		self._imageScene.clear()
		mapPixmap = QtGui.QPixmap.fromImage(image)
		mapPixmap = QtGui.QGraphicsPixmapItem(mapPixmap, None, self._imageScene)
		mapPixmap.mousePressEvent = self.pixelSelect

		self._pixmaps = dict()
		self._pixmaps['map'] = mapPixmap

		self.refreshEntities()

		if self._app.map.startCellPosition is not None:
			self.displayStartCell(self._app.map.startCellPosition[0], self._app.map.startCellPosition[1])

		self._scaleFactor = 1.0

		self.menuBar().mapOpened.emit()

		if self._app.getSaveFileName() is None:
			self._app.flagAsUnsaved()
예제 #4
0
파일: Rpg.py 프로젝트: rrpg/engine
	def _runAction(self, renderJson=False):
		"""
		Method to execute when an action is set and ready to be executed.
		"""
		if self._savedGame is None:
			raise core.exception.exception(_('ERROR_SAVED_GAME_NEEDED_TO_RUN_ACTION'))
		elif not self._player.isConnected():
			raise core.exception.exception(_('ERROR_CONNECTED_PLAYER_NEEDED_FOR_COMMAND'))
		elif self._action is None:
			raise core.exception.exception(_('ERROR_NO_ACTION_SET'))

		try:
			c = command_factory.factory.create(
				self._player,
				self._action,
				self._savedGame['id_saved_game']
			)

			self._action = None

			if c == command_factory.quit:
				return c

			result = c.run()
			if not renderJson:
				result = c.render(result)
			return result
		except core.exception.exception as e:
			return self.renderException(e, renderJson)
예제 #5
0
	def createMap(self):
		"""
		Method called when the "Create" button is pressed.
		The filled values are checked and if they are correct, a map is
		generated, in a thread
		"""
		valid = True
		try:
			name = str(self._mapNameField.text()).strip()
			width = self._mapWidthField.value()
			height = self._mapHeightField.value()

			if width <= 0 or height <= 0:
				self.displayMessage(_('ERROR_INVALID_WIDTH_HEIGHT_VALUE'))
				valid = False
			elif name == "":
				self.displayMessage(_('ERROR_EMPTY_MAP_NAME'))
				valid = False
		except ValueError:
			self.displayMessage(_('ERROR_INVALID_WIDTH_HEIGHT_VALUE'))
			valid = False

		if valid:
			self._app.setMapName(name)
			name = config.tempDir + '/' + self._app.escapeName(name)
			self._app.setMapFileName(name)
			self.displayMessage(_('LOADING_GENERATION_TEXT'))
			self._saveButton.setEnabled(False)
			self._cancelButton.setEnabled(False)
			self._thread = worker.generatorThread(self._app, width, height)
			self._thread.generatorError.connect(self.displayMessage)
			self._thread.generatorSuccess.connect(self._parent.openMap)
			self._thread.generatorSuccess.connect(self.close)
			self._thread.start()
예제 #6
0
파일: testTake.py 프로젝트: rrpg/engine
 def test_out_of_range_container_index_text(self):
     self.rpg.setAction([_("TAKE_COMMAND"), "Heavy breastplate", "wardrobe", 0])
     output = self.rpg._runAction()
     self.assertEquals(output, _("ERROR_OUT_OF_RANGE_ITEM_CONTAINER_INDEX_%d") % (2,))
     self.rpg.setAction([_("TAKE_COMMAND"), "Heavy breastplate", "wardrobe", 3])
     output = self.rpg._runAction()
     self.assertEquals(output, _("ERROR_OUT_OF_RANGE_ITEM_CONTAINER_INDEX_%d") % (2,))
예제 #7
0
	def validateFormData(self):
		valid = True
		internalName = str(self._npcInternalNameField.text()).strip()
		name = str(self._npcNameField.text()).strip()
		species = int(self._npcSpeciesField.currentIndex())
		gender = int(self._npcGenderField.currentIndex())

		if internalName == "":
			self.displayMessage(_('ERROR_EMPTY_NPC_INTERNAL_NAME'))
			valid = False
		elif self._editedRow != internalName and self._app.hasEntityWithName(self.entityType, internalName):
			self.displayMessage(_('ERROR_DUPLICATE_NPC_INTERNAL_NAME'))
			valid = False
		if name == "":
			self.displayMessage(_('ERROR_EMPTY_NPC_NAME'))
			valid = False
		if species < 0 or species >= len(self._app.map.getSpeciesNames()):
			self.displayMessage(_('ERROR_INVALID_NPC_SPECIES'))
			valid = False
		if gender < 0 or gender >= len(map.map.getGenders()):
			self.displayMessage(_('ERROR_INVALID_NPC_GENDER'))
			valid = False

		if valid is False:
			return False

		return {
			'name': name,
			'gender': self._npcGenderField.currentIndex(),
			'species': self._npcSpeciesField.currentIndex(),
			'internalName': internalName
		}
예제 #8
0
파일: attack.py 프로젝트: rrpg/engine
	def render(self, data):
		attackConfirm = _('ATTACK_CONFIRM_PLAYER_TO_ENEMY_{enemy}_{damages}')
		attackConfirmEnemy = _('ATTACK_CONFIRM_ENEMY_TO_PLAYER_{enemy}_{damages}')
		attackVictory = _('ATTACK_VICTORY_{enemy}')
		attackLost = _('ATTACK_LOST_{enemy}')
		dataFormat = {
			'enemy': data['enemy']['name'],
			'damages': data['attackResult']['damagesToEnemy']
		}
		output = [attackConfirm.format(**dataFormat)]

		if data['attackResult']['damagesToPlayer'] is not None:
			dataFormat = {
				'enemy': data['enemy']['name'],
				'damages': data['attackResult']['damagesToPlayer']
			}
			output.append(attackConfirmEnemy.format(**dataFormat))


		if data['attackResult']['fightFinished']:
			dataFormat = {
				'enemy': data['enemy']['name']
			}
			if data['attackResult']['winner'] == self._player:
				output.append(attackVictory.format(**dataFormat))
			else:
				output.append(attackLost.format(**dataFormat))

		return '\n'.join(output)
예제 #9
0
파일: talk.py 프로젝트: rrpg/engine
	def run(self):
		"""
		Say something to a character in the player's area.
		"""
		if len(self._args) == 0:
			raise core.command.exception(_('ERROR_TALK_NO_CHARACTER_GIVEN'))
		elif len(self._args) == 1:
			raise core.command.exception(_('ERROR_TALK_NO_SENTENCE_GIVEN'))

		characterName = self._args[0]
		triggerWord = self._args[1]
		c = character.character.searchByNameAndIdArea(
			characterName, self._player.getAreaId()
		)

		if c is None:
			raise character.exception(_('ERROR_TALK_UNKNOWN_CHARACTER'))

		s = sentence.sentence.loadByCharacterIdAndTriggerWord(
			c.getId(), triggerWord
		)

		if len(s) is 0:
			raise sentence.exception(_('ERROR_TALK_UNKNOWN_SENTENCE'))

		s = s[random.randint(0, len(s) - 1)]
		return {
			'question': triggerWord,
			'character': characterName,
			'answer': self.processSentence(
				s.getSentence(), self._player._model['name']
			)
		}
예제 #10
0
	def create(p, commandFull, savedGameId=None):
		"""
		command.factory.create(p, commandFull, savedGameId=None) -> command.command

		Create the desired command.

		@param p player.player Current player.
		@param commandFull list command to run, the first element of the list
			is the command, the other elements are the command's arguments.

		@return the created command
		"""

		cmd = commandFull[0]
		del commandFull[0]

		if cmd in (_('QUIT_COMMAND'), _('QUIT_SHORT_COMMAND')):
			return quit
		elif cmd in factory.mapping.keys():
			cmd = factory.mapping[cmd]
			module = sys.modules['core.commands.' + cmd['command']]

			if p.isFighting() and not cmd['allowed_while_fighting']:
				raise core.command.exception(_('ERROR_DENIED_COMMAND_WHILE_FIGHTING'))

			cmd = getattr(module, cmd['command'])()
		else:
			raise core.command.exception(_('ERROR_UNKNOWN_COMMAND'))

		cmd.setArgs(commandFull)
		cmd.setPlayer(p)
		cmd.setSavedGameId(savedGameId)
		return cmd
예제 #11
0
파일: testLook.py 프로젝트: rrpg/engine
	def test_directions_text(self):
		self.rpg.setAction([_('LOOK_COMMAND'), _('LOOK_DIRECTIONS_PARAM')])
		output = self.rpg._runAction()
		self.assertEquals(
			output, _('AVAILABLE_DIRECTIONS') + '\n    ' +\
				_('DIRECTION_KEY_SOUTH')
		)
예제 #12
0
	def creationForm(self):
		"""
		Method which creates the form to add a species.
		Returns a layout containing the form elements.
		"""
		form = QtGui.QGridLayout()

		self._messageLabel = QtGui.QLabel()
		self._messageLabel.setWordWrap(True)

		nameLabel = QtGui.QLabel(_('SPECIES_NAME_LABEL'))
		self._nameField = QtGui.QLineEdit()
		self._nameField.textChanged.connect(self.updateCreateButton)

		internalNameLabel = QtGui.QLabel(_('SPECIES_INTERNAL_NAME_LABEL'))
		self._internalNameField = QtGui.QLineEdit()
		self._internalNameField.textChanged.connect(self.updateCreateButton)
		descriptionLabel = QtGui.QLabel(_('SPECIES_DESCRIPTION_LABEL'))
		self._descriptionField = QtGui.QTextEdit()
		self._descriptionField.textChanged.connect(self.updateCreateButton)

		self._saveButton = QtGui.QPushButton(_('CREATE_BUTTON'))
		self._saveButton.setEnabled(False)
		self._saveButton.clicked.connect(self.createSpecies)

		form.addWidget(self._messageLabel, 0, 0, 1, 2)
		form.addWidget(internalNameLabel, 1, 0)
		form.addWidget(self._internalNameField, 1, 1)
		form.addWidget(nameLabel, 2, 0)
		form.addWidget(self._nameField, 2, 1)
		form.addWidget(descriptionLabel, 3, 0)
		form.addWidget(self._descriptionField, 3, 1)
		form.addWidget(self._saveButton, 4, 1)

		return form
예제 #13
0
파일: testRpg.py 프로젝트: rrpg/engine
	def test_command_with_no_player(self):
		rpgEngine = Rpg.Rpg()
		rpgEngine.initWorld(self.dbFile)
		rpgEngine.initSavedGame(self.idEmptySavedGame)
		rpgEngine.setAction([_('LOOK_COMMAND')])
		with self.assertRaises(core.exception.exception) as raised:
			rpgEngine._runAction(True)
		self.assertEquals(str(raised.exception), _('ERROR_CONNECTED_PLAYER_NEEDED_FOR_COMMAND'))
예제 #14
0
파일: main.py 프로젝트: rrpg/engine
	def formatSavedGameName(s):
		if s['id_player'] is None:
			return _('EMPTY_SAVED_GAME')
		else:
			data = {
				'login': s['login']
			}
			return _('SAVED_GAME_INFO_{login}').format(**data)
예제 #15
0
파일: main.py 프로젝트: rrpg/engine
	def yesNoQuestion(self, question):
		v = None
		yesNo = {'yes': _('ANSWER_YES'), 'no': _('ANSWER_NO')}
		questionDataFormat = {'choices': '({yes}/{no})'.format(**yesNo)}
		while v not in yesNo.values():
			v = utils.read(question.format(**questionDataFormat))

		return v == _('ANSWER_YES')
예제 #16
0
파일: map.py 프로젝트: rrpg/world-editor
	def checkForExport(self):
		"""
		Method to check if a cell is ready to be exported (start cell selected)
		"""
		if self.startCellPosition is None:
			raise exception(_('ERROR_NO_START_CELL_SELECTED'))
		if len(self.species) is 0:
			raise exception(_('ERROR_NO_SPECIES'))
예제 #17
0
파일: testLook.py 프로젝트: rrpg/engine
	def test_region_text(self):
		self.rpg.setAction([_('LOOK_COMMAND'), _('LOOK_REGION_PARAM')])
		output = self.rpg._runAction()
		expected = [
			_('CURRENT_REGION_%s') % 'The High lands',
			_('AREA_HAS_SAVE_POINT')
		]
		self.assertEquals(output, '\n'.join(expected))
예제 #18
0
파일: place.py 프로젝트: rrpg/engine
	def getFromEntranceArea(idArea, t):
		if t not in types:
			raise exception(_('ERROR_UNKNOWN_PLACE_TYPE'))

		if t == _('PLACE_TYPE_DUNGEON'):
			return dungeon.getAvailable(idArea)
		elif t == _('PLACE_TYPE_CAVE'):
			return cave.getAvailable(idArea)
예제 #19
0
파일: testDrop.py 프로젝트: rrpg/engine
	def test_quantity_too_low_text(self):
		inv = self.getInventory()

		self.rpg.setAction([_('DROP_COMMAND'), 0, 'Heavy breastplate'])
		output = self.rpg._runAction()
		self.assertEquals(output, _('ERROR_DROP_TOO_LOW_QUANTITY'))

		self.compareInventory(inv)
예제 #20
0
파일: testDrop.py 프로젝트: rrpg/engine
	def test_quantity_too_low_json(self):
		inv = self.getInventory()

		self.rpg.setAction([_('DROP_COMMAND'), 0, 'Heavy breastplate'])
		output = self.rpg._runAction(True)
		self.assertEquals(output, {"error": {"message": _('ERROR_DROP_TOO_LOW_QUANTITY'), "code": 1}})

		self.compareInventory(inv)
예제 #21
0
파일: testDrop.py 프로젝트: rrpg/engine
	def test_invalid_quantity_text(self):
		inv = self.getInventory()

		self.rpg.setAction([_('DROP_COMMAND'), 'ten', 'Heavy breastplate', 'chest', 1])
		output = self.rpg._runAction()
		self.assertEquals(output, _('ERROR_DROP_INVALID_FORMAT_QUANTITY'))

		self.compareInventory(inv)
예제 #22
0
파일: testDrop.py 프로젝트: rrpg/engine
	def test_invalid_quantity_json(self):
		inv = self.getInventory()

		self.rpg.setAction([_('DROP_COMMAND'), 'ten', 'Heavy breastplate', 'chest', 1])
		output = self.rpg._runAction(True)
		self.assertEquals(output, {"error": {"message": _('ERROR_DROP_INVALID_FORMAT_QUANTITY'), "code": 1}})

		self.compareInventory(inv)
예제 #23
0
파일: map.py 프로젝트: rrpg/world-editor
	def _exportWorldCreation(self, thread, db, name):
		"""
		Method to export the world in the DB.
		"""
		c = db.cursor()

		thread.notifyProgressLocal.emit(0, _('LOCAL_PROGRESS_REGIONS_CREATION'))
		# Create main region
		query = str("INSERT INTO region (region_name) VALUES (?)")
		c.execute(query, [name])

		thread.notifyProgressLocal.emit(33, _('LOCAL_PROGRESS_AREA_TYPES_CREATION'))
		# Create area types
		query = "INSERT INTO area_type (name) VALUES "
		areaTypesCodes = checks.getGroundTypes()
		valuesInsert = list()
		for t in self._placesTypes.keys():
			valuesInsert.append("('" + t + "')")
		values = list()
		for t in areaTypesCodes:
			valuesInsert.append("(?)")
			values.append(t)
		query = query + ', '.join(valuesInsert)
		c.execute(query, values)

		thread.notifyProgressLocal.emit(66, _('LOCAL_PROGRESS_AREAS_CREATION'))
		# Get area types IDs
		query = "SELECT id_area_type, name FROM area_type"
		c.execute(query)
		result = c.fetchall()
		areaTypes = dict()
		for r in result:
			if r[1] in areaTypesCodes:
				code = areaTypesCodes[r[1]]
				areaTypes[code] = {'id_area_type': r[0], 'name': r[1]}

		# Open text file containing cells infos
		query = "INSERT INTO area (id_area_type, id_region, container, x, y, directions) VALUES (?, ?, ?, ?, ?, ?)"
		nbAreas = 0
		for x in self.cells:
			for y in self.cells[x]:
				t = areaTypes[self.cells[x][y][0]]
				if t['name'] == 'water':
					continue

				nbAreas = nbAreas + 1
				areas = [
					areaTypes[self.cells[x][y][0]]['id_area_type'],
					1,
					"world",
					x,
					y,
					self.cells[x][y][1]
				]
				c.execute(query, areas)

		thread.notifyProgressLocal.emit(100, _('LOCAL_PROGRESS_FINISHED'))
예제 #24
0
파일: testTake.py 프로젝트: rrpg/engine
 def test_item_text(self):
     self.rpg.setAction([_("TAKE_COMMAND"), "Heavy breastplate"])
     output = self.rpg._runAction()
     self.assertEquals(
         output, _("TAKE_CONFIRMATION_%(quantity)s_%(name)s") % {"quantity": 1, "name": "Heavy breastplate"}
     )
     self.rpg.setAction([_("LOOK_COMMAND"), _("LOOK_OBJECTS_PARAM")])
     output = self.rpg._runAction()
     self.assertEquals(output, _("AVAILABLE_ITEMS") + "\n" + "  5 Heavy breastplate")
예제 #25
0
파일: testSave.py 프로젝트: rrpg/engine
	def test_no_save_move_json(self):
		self.rpg.setAction([_('MOVE_COMMAND'), _('DIRECTION_KEY_SOUTH')])
		outputMove = self.rpg._runAction(True)

		self.initialiseClient()

		self.rpg.setAction([_('LOOK_COMMAND'), _('LOOK_REGION_PARAM')])
		outputLook = self.rpg._runAction(True)
		self.assertNotEquals((outputMove['x'], outputMove['y']), (outputLook['region']['x'], outputLook['region']['y']))
예제 #26
0
파일: testDrop.py 프로젝트: rrpg/engine
	def test_out_of_range_container_index_json(self):
		self.rpg.setAction([_('TAKE_COMMAND'), 'Heavy breastplate'])
		self.rpg._runAction(True)
		self.rpg.setAction([_('DROP_COMMAND'), 'Heavy breastplate', 'wardrobe', 0])
		output = self.rpg._runAction(True)
		self.assertEquals(output, {"error": {"message": _('ERROR_OUT_OF_RANGE_ITEM_CONTAINER_INDEX_%d') % (2,), "code": 1}})
		self.rpg.setAction([_('DROP_COMMAND'), 'Heavy breastplate', 'wardrobe', 3])
		output = self.rpg._runAction(True)
		self.assertEquals(output, {"error": {"message": _('ERROR_OUT_OF_RANGE_ITEM_CONTAINER_INDEX_%d') % (2,), "code": 1}})
예제 #27
0
파일: testDrop.py 프로젝트: rrpg/engine
	def test_out_of_range_container_index_text(self):
		self.rpg.setAction([_('TAKE_COMMAND'), 'Heavy breastplate'])
		self.rpg._runAction()
		self.rpg.setAction([_('DROP_COMMAND'), 'Heavy breastplate', 'wardrobe', 0])
		output = self.rpg._runAction()
		self.assertEquals(output, _('ERROR_OUT_OF_RANGE_ITEM_CONTAINER_INDEX_%d') % (2,))
		self.rpg.setAction([_('DROP_COMMAND'), 'Heavy breastplate', 'wardrobe', 3])
		output = self.rpg._runAction()
		self.assertEquals(output, _('ERROR_OUT_OF_RANGE_ITEM_CONTAINER_INDEX_%d') % (2,))
예제 #28
0
파일: testSave.py 프로젝트: rrpg/engine
	def test_save_no_change_json(self):
		self.rpg.setAction([_('SAVE_COMMAND')])
		self.rpg._runAction(True)

		self.initialiseClient()

		self.rpg.setAction([_('INVENTORY_COMMAND')])
		output = self.rpg._runAction(True)
		self.assertEquals(output, [])
예제 #29
0
    def setSaveMapName(self, name):
        """
		Set the map's name used to save the map
		"""
        name = str(name)
        if not os.path.exists(os.path.dirname(name)):
            raise BaseException(_('ERROR_UNEXISTING_FOLDER'))
        elif os.path.exists(name) and not os.path.isfile(name):
            raise BaseException(_('ERROR_NOT_A_FILE'))
        self._saveFileName = name
예제 #30
0
파일: move.py 프로젝트: rrpg/engine
	def run(self):
		"""
		c.run()

		Move the player in the desired direction.
		"""
		if len(self._args) == 0:
			raise core.command.exception(_('ERROR_MOVE_NO_DIRECTION_GIVEN'))

		direction = self._args[0]
		if direction not in area.area.getDirections():
			raise core.command.exception(_('ERROR_MOVE_INVALID_DIRECTION_%s') % direction)
		curAreaId = self._player.getAreaId()
		curArea = area.model.loadById(curAreaId)

		a = area.area.getNeighbourFromDirection(curAreaId, direction)

		if area.area.canGoTo(curArea['directions'], direction) is False or a is None:
			raise core.command.exception(_('ERROR_MOVE_DIRECTION_NOT_AVAILABLE'))

		ret = {'direction': direction, 'x': a._model['x'], 'y': a._model['y']}
		wasFighting = self._player.isFighting()
		f = fight.getFight()
		if wasFighting:
			enemy = f.enemy

			if not fight.canFlee(self._player._model, enemy):
				raise core.fight.exception(_('ERROR_FLEE_FIGHT_FAILS'))

			fight.stopFight()
			ret['flee'] = True
			ret['enemy'] = enemy['name']

		self._player.goTo(a._model['id_area'])

		# let's be fair, if the player succesfully ran away from a
		# fight, he probably does not want to arrive right away in a
		# new one
		enemy = None
		if not wasFighting:
			probability = randint(0, 1000) / 1000.0
			enemy = creature.creature.getFromAreaType(
				a._model['id_area_type'],
				probability
			)

		if enemy is not None:
			ret['enemy'] = enemy['name']
			f = fight.startFight(self._player, enemy)
			# Deal with enemy attacking first
			damages = f.enemyTriesToAttackFirst(self._player)
			if damages is not None:
				ret['damages'] = damages

		return ret
예제 #31
0
async def cmd_start(message: types.Message):
    print('START COMMAND')
    # NOTE: This is a test translation. For more info visit: https://github.com/aiogram/aiogram/blob/dev-2.x/examples/i18n_example.py
    await message.reply(_('Hi!!'))