代写program、代做Python程序语言

日期：2024-04-11 08:47

Welcome to A1.1 - Pokemon!

Welcome to the wonderful world of Pokemon. Pokemon Battles is a game played

between teams of opposing pokemon in an attempt to see who is the very best, like no

one ever was! Pokemon have stats like attack and defense, can evolve into other

monsters, and level up.

In this assignment you'll be working on many of the features of the Pokemon Battles

game, which should also test you on your ability to apply the concepts covered in the

first 4 weeks of Fundamentals of Algorithms.

But, this is too easy! To make sure you are demonstrating all of the topics covered in

this unit, the following restrictions are in place.

? Any use of python inbuilt lists, dictionaries, sets, etc. Is banned. Use of such

structures nulls both the test case and approach marks for the affected

task. You can however use fixed size tuples. (Please also read the FAQ

announcement in the Forum.)

? Accessing the internals of the data_structures classes outside of the definition of

the class is strictly prohibited (You can't access .array of CircularQueue for

example, only interact with its methods)

? Not only does your code need to be functional, it needs to be the most efficient

choice that is best suited for the problem. In general, if there is a choice that is

efficient and requires less code, not choosing this will lose you marks (So don't

use an array when a queue would also work).

With all that in mind, make sure to read the next slide for a bunch of small tid-bits and

we hope you enjoy this assignment!

Basic Introduction to Pokemon Battles

Basic Premise

Pokemon

The titular Pokemon are the backbone of the Pokemon Battles. There are different

types of pokemon each with their own names and stats, and one type of pokemon can

evolve into another type of pokemon when they level up.

Pokemon have the following information:

? Health

? Level

? Defence

? Type

? Battle Power (attack points)

? Name

? Evolution Line

? Experience

? Speed

These stats will be covered over the future tasks but here is a short overview of each of

them:

1. Health - This is the stat that lets you know how many health points a Pokemon has

before it faints. Once the Pokemon gets attacked, it loses some health and once the

health drops to 0, the Pokemon faints

2. Level - This stat refers to the level that the Pokemon is on. Once a Pokemon battles

another and makes it faint, the level of the Pokemon goes up by 1, boosting most of its

other stats.

3. Defence - This stat refers to the resistance that is offered by the Pokemon when it

gets attacked. You will learn more about the use of this stat when we discuss battling.

4. Type - A Pokemon's type affects the amount of damage it can do to another

Pokemon. You will learn more about this in Task 1.

5. Battle Power - This stat refers to the amount of base damage a Pokemon does to

another during the course of a battle.

6. Name - This refers to the name of the Pokemon

7. Evolution Line - This is a list of the Evolution names for this line of Pokemon. The

length of this list can vary as many Pokemon don't evolve, evolve once or even twice in

some cases!

8. Experience - This stat refers to the experience that a Pokemon has. A pokemon gains

experience from battling another pokemon.

9. Speed - This stat refers to the speed of the Pokemon. Speed determines how fast the

Pokemon is and the faster Pokemon attacks first.

What is PokemonBase?

Because there are over 70 Pokemon to define, and we don't want to write out all the

classes individually. In particular, because almost all of the logic for all Pokemon are the

same, all we have to do is define this shared logic in PokemonBase. Then Pokemon.py

creates different classes, which all inherit from PokemonBase, and implements all of the

abstract class methods at the bottom of pokemon_base.py.

For example, you can do the following without touching the assignment and it works

just fine:

Run

PYTHON

1

2

3

4

5

6

7

8

from pokemon import Charmander, Gastly

charmander = Charmander()

gastly = Gastly()

print(charmander.get_name()) # Charmander

print(charmander.get_poketype()) # PokeType.FIRE

print(gastly.get_evolution()) # ['Gastly', 'Haunter', 'Gengar

']

Teams

Pokemon are combined to form teams, which are used in battle. There are multiple

options for teams, such as the team mode, and selection mode, but these will be

covered in more detail in task 3.

Battling

Battling is done between two teams in a turn-based manner, where every "turn"

includes an action from both teams. In a battle, each team selects one Pokemon to be

currently out on the field, while the rest of each team waits to help out.

Battle anatomy

In a battle, turns continue to occur until one or both teams have no more pokemon left

(in the team and on the field). If a pokemon on the field is killed (HP <= 0), then a new

pokemon from the team is sent out at the end of the turn.

Turn anatomy

In a Battle turn, each team selects an action, either ATTACK or SPECIAL. If SPECIAL is

chosen, the pokemon is returned to the team, the method .special() is called on the

team object, and a pokemon is retrieved from the team (possibly the same pokemon).

If ATTACK is chosen, then the currently out-on-the-field pokemon attacks the currently

out-on-the-field pokemon for the other team.

Two things to note:

1. SPECIAL actions are always completed before ATTACK actions

2. If both teams ATTACK, then some special logic occurs:

The pokemon with the higher speed stat attacks first. If the slower pokemon is still alive

after this (HP > 0), then it can attack in retaliation. If the speed stat of both pokemon is

equal, then both pokemon attack simultaneously, ignoring whether the attack they are

receiving would kill them.

The process of pokemon attacking pokemon is defined as follows:

Step 1: Compute the damage

This is done by comparing pokemon1's attack (call it attack) and pokemon2's defense

(call it defense).

? If defense < attack / 2: damage = attack - defense

? Otherwise, If defence < attack: damage = ceil(attack * 5/8 - defense / 4)

? Otherwise, damage = ceil(attack / 4)

Step 2: Apply multipliers

When two Pokemon attack, the element of each Pokemon is considered. For example,

Squirtle is a Water Elemental Pokemon, where as Charmander is a Fire Elemental

Pokemon. Since Water has an effectiveness coefficient of 2 against Fire, this is used to

multiply by the calculated damage:

effective_damage = damage * 2

Then, you apply the trainer's Pokedex completion multiplier, which can be obtained as

a ratio between the attacking trainer's Pokedex completion vs the defending trainer's

Pokedex completion. This is discussed in detail (and will make more sense once you

read) Task 3 and the Battle Logic slide

effective_damage = effective_damage *

(attacking_pokedex_completion/defending_pokedex_completion)

Step 3: Get the ceiling of the effective_damage

Since at this point the damage may have a decimal component, round this number up.

Step 4: Deduct HP from pokemon2 equal to the effective_damage.

Note: During defense pokemon2 might reduce the effective_damage by half.

Leveling up

If at the end of a turn, one Pokemon is alive and the other is not, then the alive

Pokemon levels up. This may change the Pokemon's stats, and if they have an

evolution, will force the Pokemon to evolve.

When leveling up the difference between a Pokemon's max hp and current hp must be

maintained.

Evolution

Some Pokemon types can evolve into other Pokemon types. The PokemonBase method

get_evolution will tell you whether this Pokemon type can evolve. If the pokemon

cannot evolve, the returned list only contains the Pokemon itself. Otherwise, the

returned value is a list of its evolution names. For example

Charmander.get_evolution() == ['Charmeleon', 'Charizard'].

However, for a Pokemon (object) to evolve in battle, the following must be true:

? The Pokemon type must be able to evolve (get_evolution is returns just the

current Pokemon's name instead. i.e. - it doesn't have an evolution)

? The Pokemon must be a different level from the one it originally started as

To evolve a Pokemon, the evolve method is called. The evolve method modifies the

current object, changing its stats and upgrading the Pokemon to its new evolution.

Battle Tower

The Battle Tower is a battle feature where one team faces a gauntlet of other teams in

succession, and is covered in more detail in Task 4.

[TASK1] Element Effectiveness +

Pokemon Base

We are going to set up the Element effectiveness in this task. All your work will be in the

pokemon_base.py file.

For starters, you have been given a file called type_effectiveness.csv which contains a

table defining the type effectiveness for each type against each other.

Your job in this task is to:

? populate the EFFECT_TABLE in the TypeEffectiveness class. Some of the code

has already been done for you so you need to complete the rest.

? complete the method get_effectiveness which returns a float based on the

attacking and defending types supplied as arguments to the method.

Make sure to set up the table correctly. One example is that get_effectiveness(PokeType.WATER,

PokeType.GRASS) should return 0.5

Additionally, have a look at the PokemonBase class. Most of these methods have already

been done for you, however, you will need to implement the following:

? _evolve: This method will evolve the Pokemon. You don't need to check if the

pokemon needs to evolve as this is done in the level_up method. However,

what you need to do is to:

o change the name of the pokemon to the next in the evolution line

o set the battle power, health, speed and defence to 1.5 times what it

currently is set to

? attack: This method will return the attack points when this Pokemon is battling.

This method should return the product of the Pokemon's current battle_power

and the type effectiveness of the Pokemon vs the type of the defending

Pokemon

Think carefully about the data structure that you are going to use in this task!

[TASK 2] Poke Team

A reminder that use of inbuilt lists, dictionaries, sets are banned, and using less suited data structures

will result in loss of marks.

For methods that differ in complexity based on the team mode selected, please include separate

complexity analysis for all 3 team modes (For example, O(1) best/worst for FRONT, O(1) best/worst for

BACK, O(n^5log(n!)) for OPTIMISE)

Now that we have Pokemon and can create them and view stats, it's time to group

them into a team, in preparation for our battles!

You will be working on the file poke_team.py

Teams are a bit complicated, and have a few different creation options, so we'll go

through all the details here.

What is a Team?

A team is an ordered collection of Pokemon, with an upper limit on the total number of

monsters contained (this is currently set at 6, but you should design your code so that

this limit is easily adjustable)

Team should have the following instance variable, although you can have more:

? self.team to store the team that the trainer has

Teams have the following methods:

? __init__ , to initialise the team. This SHOULD NOT take any additional

arguments. However, if you are adding some arguments, you should provide

default values for them so they don't fail the tests.

? choose_manually, to let the user choose upto 6 Pokemon. Please note that the

user should have an option to choose less than 6 Pokemon if they choose to do

so

? choose_randomly, to generate a team randomly chosen Pokemon. This should be

equal to the TEAM_LIMT (normally 6).

o Update: This method has been provided to you in the scaffold.

? regenerate_team(battle_mode, criterion=None), to heal all of the pokemon to

their original HP while preserving their level and evolution. This should also

assemble the team according to the battle mode (discussed later)

? assemble_team, to place your pokemon in the appropriate ADT when a battle

mode is selected (you will need to leave this empty right now but you will fill this

in later in the next task)

? special , which takes different effects based on the type of battle, which will be

covered in the next task

? __getitem__, to retrieve a Pokemon at a specific index of the team

? len(team), should return the current length of the team

? str(team) , should return a string with the current members of the team with

each member on a new line

In a battle, Pokemon will be retrieved from the team and used in battle. If a Pokemon is

swapped out, then it is added back into the team.

What is a Trainer?

A trainer is the holder of a Pokemon team. The trainer has a name, a team and a

Pokedex. A Pokedex registers if a trainer has seen a particular pokemon, whether it be

in their own team or during battle.

The class Trainer should have the following methods:

? __init__, which should take the name as an argument and set the Trainer's

name, initialise a new PokeTeam and also a Pokedex.

? pick_team, which should pick a team based on the mode that is supplied to the

method as an argument. Pick team can only have the values 'Random' or

'Manual'. You should return an error if one of these options is not chosen

? get_team, which should return the current PokeTeam

? register_pokemon, which should register a pokemon (by its PokeType) as seen on

the trainer's Pokedex

? get_pokedex_completion, which should return a rounded float ratio of the

number of different TYPES of pokemon seen vs the total number of TYPES of

pokemon available rounded to 2 decimal points. For this point, two FIRE type

pokemon count as the exact same

? str(trainer), should return a string of the following format: Trainer

<trainer_name> Pokedex Completion: <completion>%

You need to convert your pokedex completion to a percentage here by

multiplying it by 100

Battle Logic

Commencing The Battle

After being positioned, the teams battle. Battling involves attacking and defending,

after which HP is lost according to the attack stat and the damage after being attacked

stat. Remember to use the Pokedex multiplier here!

The battle begins with the first Pokemon of each team (positioned in the right order)

getting into battle. The battle between two units (say P1 and P2) proceeds as follows:

? If the speed of unit P1 is greater than that of P2, P1 attacks and P2 defends.

? If the speed of unit P2 is greater than that of P1, P2 attacks and P1 defends.

? If the speeds of P1 and P2 are identical, then both attack and defend

simultaneously, regardless of whether one, or both, would faint in combat.

Alternately after this initial attack, if the defending Pokemon has not fainted

(that is, it still has HP > 0), then they will retort with their own attack to the first

Pokemon. Once this has happened, there can only be three scenarios:

? One of the two Pokemon faints. In this case, the other Pokemon gains 1 level.

The other Pokemon then goes back to the team.

? Both Pokemon faint. In this case, we just leave their carcasses on the battlefield

and move on.

? Both Pokemon are still alive after they have attacked each other. In this case,

they both lose 1 HP. If they are still alive after losing this 1 HP, they are sent back

to their teams. If a Pokemon faints here due to losing this 1 HP and the other

Pokemon is alive, such a Pokemon still gains 1 level.

Battle Multipliers

As you may remember, in Pokemon Base, we used a multiplier based on the type of

Pokemon that is attacking and the type of Pokemon that is defending.

While battling, we are going to introduce another multiplier, which grows stronger with

trainer experience.

When you are attacking another pokemon, multiply the attack damage with the ratio

between the pokedex completion of the attacker vs the pokedex completion of the

defender.

For example, if Pokemon p1 that belongs to the trainer t1 is attacking Pokemon p2 that

belongs to the trainer t2 then:

attack_damage = ceil(p1.attack(p2) *

(t1.get_pokedex_completion()/t2.get_pokedex_completion())

This attack damage can then be used in the defend method of the defending pokemon

Ending the Battle

The game ends when at least one of the teams is empty (i.e., it has no usable

Pokemon).

[TASK 3] Battle!

A reminder that use of inbuilt lists, dictionaries, sets are banned, and using less suited data structures

will result in loss of marks.

Finally, we make it to the Battles :)

Battle Modes

Before we commence the battle class, we need to understand how battle modes work.

There are overall 3 battle modes available:

Set Mode

In a Set mode, we will follow a 'King of the Hill' style of combat. In this mode, a

particular Pokemon from one trainer's team keeps fighting until its fainted (health <=

0). The pokemon gains experience and levels up the same if it is able to faint the

pokemon from the other team, but it keeps fighting until it is exhausted. Here is a

representation of how this may occur:

Note: The initial composition of the team should be in reverse order. That is, the first Pokemon to

battle should be the last Pokemon that was selected.

You have been given certain Abstract Data Types (ADTs) in the data_structures folder,

one of which can be used for this task. Think about what you need to accomplish and

then pick a suitable ADT.

Rotating Mode

We will now focus on the rotating mode for battle. In this mode, a Pokemon fights a

round, and then is sent to the back of the team, making the next pokemon in the party

fight the next round. The battle ends when at least one of the teams is empty. You

should again choose one of the ADTs provided to you to make this mode work the way

it is intended.

Here is a pictorial representation of how this may look:

Optimised Mode

Now, things get a little interesting in the optimised mode! In this mode, the user gets to

choose an attribute to order their team. They can choose between Level, HP, Attack,

Defence and Speed. This order will be maintained throughout the battle, even when

the stats change after each round. The battle mode for this mode is 2. And, once again,

you need to choose from the given ADTs and once you have chosen a suitable ADT.

You need to add a new method assign_team method to assign the order of the team

based on the chosen attribute.

Improvement to the PokeTeam

First and foremost, you will need to complete the assemble_team method in the

PokeTeam class. Now that you have chosen your prefered ADTs, you can finish off the

functionality of this method. You will need to replace the self.team attribute of the

PokeTeam with your ADT of choice.

Next, complete the special method in the PokeTeam. Here are the details:

If special is called on a PokeTeam, the following should occur based on the battle

mode:

? SET MODE: If special is called during battle, this should reverse the first half of

the team

? ROTATE MODE: If special is called during battle, this should reverse the bottom

half of the team

? OPTIMISE MODE: it toggles the sorting order (from ascending to descending and

vice-versa)

Implement the Battle class

Most of the battle logic has already been discussed in the Battle Logic slide so here are

the basics of the Battle class:

In battle.py, we have the Battle class, with which you'll need to implement the

following methods:

? __init__, which initialises the battling trainers, the battle mode, and the

criterion; if applicable.

? _create_teams, which turns the PokeTeams from the two trainers into

appropriate data structures based on the mode supplied to the battle as an

initial argument.

? commence_battle, which calls the appropriate battle method from the 3 based on

the battle mode set in the initialiser. This method returns the winning trainer or

None; in the case when its a draw

The team's methods will need to be updated to support the new team formations. For example, you

will need to revisit getitem, len and str.

[TASK 4] Battle Tower

A reminder that use of inbuilt lists, dictionaries, sets are banned, and using less suited data structures

will result in loss of marks.

The final task! In the monster battles game, what's better than a battle between two

Trainers? Why multiple of course!

In the battle tower, the player (with a team of Pokemon), faces a gauntlet of teams of

Pokemon to battle.

Each team (both the player's team and the enemy teams) have some amount of lives.

The enemy teams take it in turns to battle the player's team, and the result is either a

win/loss or draw. The losing team loses a life, and in the result of a draw both teams

lose a life.

The order in which enemy teams face up against the player team is determined in the

following manner:

? Some initial ordering for the enemy teams is decided.

? After all enemy teams have fought the player team, then of the remaining

enemy teams, those with at least 1 life will fight the player again, following the

same initial ordering as before.

? Before every battle, regenerate_team is called on both teams to heal the entire

team and revive fainted monsters.

So for example, suppose we have 3 enemy trainers, A B and C, each with 2, 1 and 3

lives.

Then in the order of play, assuming that the player wins every battle:

1. We face trainer A, B and then C

2. We face trainer A, then C

3. We face trainer C

The battle tower ends when there are no enemy trainer lives left, or no lives left for the

player team, or both.

Your task is to implement the following functionality in tower.py:

BattleTower Class

? __init__ method: Initialises the class.

? set_my_trainer: Sets the player team for the battle tower, and generates

between MIN_LIVES and MAX_LIVES lives

? generate_enemy_trainers: Randomly generates n enemy teams (n is passed as a

parameter). All teams must use selection_mode RANDOM and all battle are

fought with battle mode ROTATE. Generate each team a number of lives

between MIN_LIVES and MAX_LIVES, after each team is generated but before the

next team is generated.

? battles_remaining: Returns True if there are more battles to be had, False if

either the player or all enemy teams have ran out of lives.

? next_battle: Simulates one battle in the tower, between the player team and

the next enemy team. Returns 5 values: The battle result, the player trainer, the

enemy trainer, the player lives remaining after the battle, and the enemy lives

remaining after the battle.

? enemies_defeated, you should keep a counter of the number of enemy lives

taken by the player, which this method should return.