stevenssec / pokemonbattlelib Goto Github PK

Is your feature request related to a problem? Please describe.
Users are going to want to build parties quickly, and we're going to want it to write tests.

Currently, the steps to building a party are:

1. Create the party
2. Create the pokemon
3. Set the pokemon moves
4. Set the pokemon stats
5. Set the pokemon's current hp to the max hp
6. Repeat 2-5 up to 5 more times
7. Add all the pokemon to the party

This kinda sucks, especially because of step 5.

Describe the solution you'd like

There should be some way to generate pokemon with correct stats based on the national dex number and level

The process should look more like:

1. Create the party
2. Generate a pokemon
3. Set the pokemon moves
4. Repeat 2-3 up to 5 more times
5. Add all the pokemon to the party

However, it needs to still be possible to hand craft pokemon if needed. This would be just a convenience tool.

Describe alternatives you've considered

Additional context

Add functionality for held items that affect stats. There is a lot of custom functionality here, including changing priorities, restricting moves, changing immunities, and boosting type damage.

Blocked by #8.

See https://veekun.com/dex/items/misc

Obviously, we need a type to represent a Pokemon in a battle. Keep memory footprint in mind when considering what types to use. Feel free to add any enums that you need to accomplish this.

See: https://github.com/StevensSEC/pokemonbattlelib/wiki/Requirements#pokemon

It's not necessary for the first iteration of this type to be perfect. We can change it later if needed.

Tasks

• Define the contents of type Pokemon struct that are necessary to have in a Pokemon battle, or to be able to obtain external metadata.
  • For example: the Pokemon's name should not be stored in the struct, but the National Pokedex number should since it can be used to look up the Pokemon's name.
• Implement the Stringer interface for Pokemon. Example: https://tour.golang.org/methods/17

Add transactions/helper functions to apply 1 or more status effects to a Pokemon.

We need a way to track the current state of a Pokemon battle.

It's not necessary for the first iteration of this type to be perfect. We can change it later if needed.

Tasks

• Define the contents of type Battle struct that necessary for a Pokemon battle.

Add transactions/helper functions to change friendship in Pokemon.

Add transactions/helper functions to cure one or more status effects from a Pokemon.

We need test cases to ensure the accuracy of our Pokemon battle implementation.

Eventually, we will turn these into automated test cases.

Tasks

• Describe 3 Pokemon battles from start to finish, clearly documenting the results for each turn with the reason for why it happened, and put it in the documentation (docs/example-battles.md)
  • If possible, include the RNG seed at the start of the battle, damage numbers, buffs, debuffs, etc. The more information the better.
  • One battle should be as simple as possible, avoiding edge cases, between 2 low level Pokemon (one on each side).
  • One battle should include super-effective/not-very-effective type matchups.
  • The complexity of the last battle is up to your discretion.

Is your feature request related to a problem? Please describe.
We need some way to supply the battle with turns from an Agent in a specific order in tests.

Describe the solution you'd like
An Agent that has a channel that it takes a Turn from and returns it when Act is called. This will allow us to write tests that check specific sequences of Turns easier.

Describe alternatives you've considered

Additional context

Sort turns based on move priority and add tests that specifically check for priority between turns and properly sorts them.

In a Pokemon battle, certain types of turns are supposed to occur before others.

Relevant code:

Sort turnOrder in descending order by Priority() on the corresponding turns. Allow the ability to add other factors that can affect the sorting order.

This may be useful: https://golang.org/pkg/sort/

Currently, the code generation script parses the available moves, but it does not actually output any generated code for them.

Add functionality for effects of berries in battle. Each berry is consumed upon usage and typically affects 1 or more stat values.

See: https://veekun.com/dex/items/berries

In-a-pinch

Medicine

Other

Picky Healing

Type protection

We need a Transaction that can tell the battle that a pokemon has fainted.

• Triggers when pokemon's reaches 0
• Checks to see if any pokemon in the party have not fainted, if all are fainted, battle is over
• Sends out next pokemon

In SimulateRound where it says TODO: Implement fight, make it so that the move deals damage to the target pokemon.

You can't implement all the damage modifiers right now, so just do the bare minimum.

Relevant code:

We currently use a mix of int, uint, uint8, uint16, and float64 throughout the library. I think the performance benefits do not outweigh the confusion from mixing these types together, so I suggest that we pick 1 integer type and one floating point type.

Add all items falling under the medicine category.

See https://veekun.com/dex/items/medicine

We need some way to process turns from Agents, without having the agents directly modify the state of the battle.

We need an interface to represent the entities that engage in a battle. The idea is to have an Agent interface that, when implemented, allows an end user or bot to receive information about the battle and complete a turn.

See: https://github.com/StevensSEC/pokemonbattlelib/wiki/Requirements#before-the-battle

Tasks

• Define the functions of type Agent interface that are necessary in order to accommodate the 2 use cases listed above.

Currently, the code generation for pokemon only generates code to define their national dex number, and nothing else.

Now that #6 is complete, we need to add the rest of the fields to the code generation.

We need to be able to tell the user that the battle has ended. More specifically, we need a Transaction that will end the battle.

Relevant code:

This will represent a turn where a Trainer uses an item on their Pokemon (or an opposing Pokemon in the case of using a Poke Ball in a wild Pokemon battle).

See: https://github.com/StevensSEC/pokemonbattlelib/wiki/Requirements#bag-using-an-item

Items and their effect have yet to be implemented in full, so the actual use of the item does not have to have an effect yet.

Using an item always takes precedence to any FightTurns that may occur, essentially placing it in the highest priority bracket (higher than any move would have).

• Using an item passes the turn
• Using an item takes place before FightTurns
• Add case to SimulateRound()

We decided in a GBM that LinkAgentParty was not necessary, and just increases complexity.

We need a way keep track of single and dual type Pokemon.

It's not necessary for the first iteration of this type to be perfect. We can change it later if needed.

Tasks

• Define a new type called ElementalType
• Define a utility method to determine the effectiveness of a Move/Pokemon type matchup. It should take the attacking move type and defending Pokemon type, and return some representation of it's effectiveness.
  • See type effectiveness chart: https://github.com/StevensSEC/pokemonbattlelib/wiki/Requirements-(Miscellaneous)#type-effectiveness-chart

Add support for battle items which are one-time stat boosting items.

See https://veekun.com/dex/items/battle.

Current Behavior

If a pokemon faints before taking it's turn, it will ignore the fact that it is dead, and take it's turn anyway.

To Reproduce
Code snippet to reproduce the problem (if applicable)

func TestBattleDeadPokemonForfeitTurn(t *testing.T) {
	a1 := Agent(dumbAgent{})
	a2 := Agent(dumbAgent{})
	party1 := NewParty(&a1, 0)
	pkmn1 := GetPokemon(4)
	pkmn1.Stats = [6]uint{30, 10, 10, 10, 10, 10}
	pkmn1.CurrentHP = 1
	pound := GetMove(1)
	pkmn1.Moves[0] = &pound
	party1.AddPokemon(&pkmn1)
	party2 := NewParty(&a2, 1)
	pkmn2 := GetPokemon(7)
	pkmn2.Stats = [6]uint{30, 10, 10, 10, 10, 100}
	pkmn2.CurrentHP = 30
	pkmn2.Moves[0] = &pound
	party2.AddPokemon(&pkmn2)
	b := NewBattle()
	b.AddParty(party1, party2)
	err := b.Start()
	if err != nil {
		t.Fatal("failed to start battle")
	}

	transactions, ended := b.SimulateRound()
	if !ended {
		t.Error("Expected SimulateRound to indicate that the battle has ended, but it did not.")
	}
	if n := len(transactions); n != 3 {
		t.Errorf("Expected 3 transactions to occur, got %d", n)
	}
	logtest := []struct {
		turn Transaction
		want string
	}{
		{
			turn: transactions[0],
			want: "Squirtle used Pound on Charmander for 3 damage.",
		},
		{
			turn: transactions[1],
			want: "Charmander fainted.",
		},
		{
			turn: transactions[2],
			want: "The battle has ended.",
		},
	}
	for _, tt := range logtest {
		got := tt.turn.BattleLog()
		if got != tt.want {
			t.Errorf("Expected battle log to be %s, got %s", tt.want, got)
		}
	}
}

func TestBattleDeadPokemonForfeitTurn2(t *testing.T) {
	a1 := Agent(dumbAgent{})
	a2 := Agent(dumbAgent{})
	party1 := NewParty(&a1, 0)
	pkmn1 := GetPokemon(4)
	pkmn3 := GetPokemon(387)
	pkmn1.Stats = [6]uint{30, 10, 10, 10, 10, 10}
	pkmn1.CurrentHP = 1
	pkmn3.Stats = [6]uint{30, 10, 10, 10, 10, 10}
	pkmn3.CurrentHP = 30
	pound := GetMove(1)
	pkmn1.Moves[0] = &pound
	pkmn3.Moves[0] = &pound
	party1.AddPokemon(&pkmn1, &pkmn3)
	party2 := NewParty(&a2, 1)
	pkmn2 := GetPokemon(7)
	pkmn2.Stats = [6]uint{30, 10, 10, 10, 10, 100}
	pkmn2.CurrentHP = 30
	pkmn2.Moves[0] = &pound
	party2.AddPokemon(&pkmn2)
	b := NewBattle()
	b.AddParty(party1, party2)
	err := b.Start()
	if err != nil {
		t.Fatal("failed to start battle")
	}

	transactions, _ := b.SimulateRound()
	if n := len(transactions); n != 3 {
		t.Errorf("Expected 3 transactions to occur, got %d", n)
	}
	logtest := []struct {
		turn Transaction
		want string
	}{
		{
			turn: transactions[0],
			want: "Squirtle used Pound on Charmander for 3 damage.",
		},
		{
			turn: transactions[1],
			want: "Charmander fainted.",
		},
		{
			turn: transactions[2],
			want: "Turtwig was sent out.",
		},
	}
	for _, tt := range logtest {
		got := tt.turn.BattleLog()
		if got != tt.want {
			t.Errorf("Expected battle log to be %s, got %s", tt.want, got)
		}
	}
}

Expected Behavior

Inactive pokemon should be unable to take turns. If a pokemon is deactivated before it takes it's turn, the turn is ignored.

Additional context

When using the library as intended, it's currently impossible for agents to initialize or modify the values for FightTurn.

We need a type to represent the metadata of a Pokemon's moves at runtime. This won't be responsible for handling side effects of moves yet.

See: https://github.com/StevensSEC/pokemonbattlelib/wiki/Requirements#moves

Tasks

• Define the contents of type Move struct that are necessary to have in a Pokemon battle, or to be able to obtain external metadata.
• Implement the Stringer interface for Move. Example: https://tour.golang.org/methods/17

We need an interface to handle random number generators. More specifically, we need an interface that we can use to implement various RNG algorithms used in Pokemon games. See: https://github.com/StevensSEC/pokemonbattlelib/wiki/Requirements#rng

For the initial seed, since getting the delay between the player starting the game and pressing "Continue", we can probably ignore it.

Tasks

• Create an interface type to handle setting the seed and generating random numbers between 2 values (inclusive)
• Implement this interface on a new type which implements the LCRNG described here.
  • Allow setting the seed
  • Generate seed
    • Get the date and time

This will represent a turn where a Trainer changes their active Pokemon (the one currently battling) to a Pokemon in their party that has not yet fainted.

See: https://github.com/StevensSEC/pokemonbattlelib/wiki/Requirements#pokemon-switching-out

Switching Pokemon always takes precedence to any FightTurns that may occur, essentially placing it in the highest priority bracket (higher than any move would have). (The exception is the move Pursuit, but this has not been implemented yet. It should be kept in mind while designing the type though.)

• Switching Pokemon passes the turn
• Switching Pokemon takes place before any FightTurns
• A Trainer cannot switch to a fainted Pokemon
• A Trainer cannot switch to the already active Pokemon
• Add case to SimulateRound()

Relevant code:

Held items change the way that a Pokemon battle functions drastically. Each hold item belongs to a class (such as Stat Modifier, Medicine, Berries, or other effects. Representing items will be challenging, as there are many different types of items that produce different effects. Also, we must determine if we want to include all possible items or only those which have an affect on the battle itself.

This issue should be incremental, with the data representation being the first and simplest layer.

Current Behavior

go generate does not regenerate pokedex_GEN.go

To Reproduce

1. delete pokedex_GEN.go
2. run go generate
3. See that pokedex_GEN.go is not created.

Expected Behavior

go generate should regenerate pokedex_GEN.go, even if pokedex_GEN.go is not already present.

Additional context
Seems like pokedex.go was removed. pokedex.go should be recreated with

//go:generate go run data/gen.go

Note that there is no spaces in //go:generate

• Runs tests
• Collects code coverage
• CI success status badge in README
• Code coverage badge in README

Current Behavior

GetOpponents returns the same results as GetAllies

Expected Behavior

GetAllies should return friendly targets.
GetOpponents should return enemy targets.

Additional context

We need to provide code examples for starting a new battle in the documentation. Preferably, we should have a minimal example in the readme, as well as an example or 2 in examples_test.go.

For some reason, some people's editors are not automatically running gofmt on the code. This causes erroneous changes to be made when somebody's editor does auto run gofmt, and it clogs up diffs when reviewing pull requests.

Tasks

• Have CI test to make sure gofmt won't modify any files
  • Maybe auto commit corrections?
  • test -z $(gofmt -l . | tr -d '\n') returns non-zero exit code if this test fails
• Have codegen script run gofmt on generated code

Transactions are becoming too complex to keep in the scope of battles. We can introduce a new file, transactions.go to manage the different types of transactions as they scale as well as test them separately without creating battle instances. Additionally, the logic performed by transactions should be separate so that we can unit test its functionality.

Quick example:
ItemTurn should add transactions based on the item function. Using a potion should produce an ItemTransaction (to consume the potion) and a HealTransaction (to restore HP). The handlers for both transactions should be separate functions that we can test.

Add transactions/helper functions to change a Pokemon's stat stages in battle. See https://bulbapedia.bulbagarden.net/wiki/Stat#Stat_modifiers.

This will represent a turn where a Trainer or Pokemon attempts to leave a battle.

See: https://github.com/StevensSEC/pokemonbattlelib/wiki/Requirements#run-running-away

This option has different behavior depending on if the battle is between a player Trainer and another player Trainer, a player Trainer and an NPC Trainer, or a Trainer and a wild Pokemon:

• In a battle between two player Trainers, this option is equivalent to attempt to forfeit the match. The match ends in a loss for the player Trainer who selected this option if the other Trainer selects any other option. The match ends in a draw if both Trainers select this option on the same turn.

• In a battle between a player Trainer and an NPC Trainer, this option cannot be selected, and a message is displayed to warn the player Trainer without passing their turn. NPC Trainers will not select this option.

• In a battle between a player Trainer and a wild Pokemon, if the player Trainer attempts to flee, the Speeds of the two Pokemon active in the battle are compared and success is determined using the formula linked above. If the wild Pokemon attempts to flee, it succeeds without needing to compare its Speed. If either Pokemon has an effect that prevents them from fleeing, selecting this option fails. This will not pass the turn for the Trainer, and the wild Pokemon cannot select this option.

• Multi player Trainer case functional

  • One team selecting option causes match loss for that team
  • All teams selecting option on same turn causes match draw

• Trainer and NPC case functional

  • Player receives warning upon selecting this option
  • Turn is not passed

• Trainer and wild Pokemon case functional

  • Speed comparison performed for Trainer
  • No speed comparison performed for wild Pokemon
  • Both Trainer and wild Pokemon can be rendered unable to flee

• Add case to SimulateRound()

• Running takes precedence over FightTurns

Current Behavior

Some of the current tests that check the std output are not actually checking it.

To Reproduce
If you take the TestBattleOneRound and change the expected output, the test will still pass.

Evironment:

• OS: Ubuntu 20.04

Additional context

We need some way for battles to generate random numbers predictably even if the user is running multiple battles at the same time.

To do this, we need to add a field to the battle struct with the type RNG (which is already defined in rng.go).

NewBattle should initialize this field.

Is your feature request related to a problem? Please describe.
We need some way to let users know what happened in each round of the battle.

Describe the solution you'd like
Possible solution:

• Have each turn implement a BattleLog() method that outputs a string that would be end-user facing (eg. "Bulbasaur used X for -Y HP. It was super effective!"), and also have Turns make data about the result publicly accessible so that users could do animations and stuff. The battle could then just record the turns.

Additional context
Also may be necessary to fix #49 .

The \data directory contains some extra csv files. For example, conquest_kingdoms_names.csv contains the names of the kingdoms from the Pokemon Conquest spinoff game and super_contest_effect_prose.csv contains the effect text for moves during a Super Contest. This might make it confusing what information needs to be used in the future.

Proposal

Remove csv files not directly relevant to Pokemon data, move data, or any other data that would be relevant in a Pokemon battle.

Current Behavior

pkg.go.dev doesn't seem to be picking up our nightly releases right away.

Expected Behavior

Expected documentation on pkg.go.dev to be up to date.

Additional context
Maybe it requires a new tag every time instead of updating an existing tag.

It does update, but every 2-3 weeks?

Add transactions and helper functions to manipulate EVs of a Pokemon.

We need to be able to access metadata about pokemon, moves, etc at runtime. pokedex.go should manage this information.

Desired Solution

Code generation based on files. When go build is run, it should run a script to generate the code with the metadata. This is accomplished with the magic comment go:generate.

This example will run gen.go before building the rest of the package.

//go:generate go run gen.go

The script should read some files out of the data/ directory, and generate code based on it's contents.

Tasks

• File format(s) or schemas for metadata
• API for accessing metadata
• Script for generating code
• Data entry
  • Pokemon
  • Moves