Monster Rancher Battle Card Game

Monster Rancher Battle Card GB, known in Japan as Monster Farm Battle Card GB (モンスターファームバトルカードGB, Monsutā Fāmu Batoru Kādo GB) is a handheld game released in 1999 for the Nintendo Game Boy Color system. It is the first game in Tecmo's Monster Rancher Battle Card series, featuring a card game incorporating the popular characters from the Monster Rancher series. It was followed by Monster Rancher Battle Card: Episode II for the Sony PlayStation entertainment system which featured additional monsters.

Monster Rancher Battle Card Game
Developer(s)GRC
Publisher(s)Tecmo
SeriesMonster Rancher
Platform(s)Game Boy Color
Release
  • JP: December 24, 1999
  • NA: April 2000
Genre(s)Strategy
Mode(s)Single-player, multiplayer

Gameplay

Although the Monster Rancher series is known for the ability to import game content via CDs, Monster Rancher Battle Card GB has no equivalent functionality. Instead, the player takes a short "personality test" to determine his starting deck and then can win additional cards by defeating opponents as well as new monster cards by defeating dungeon bosses. While a code system is also in place, only a select few cards catering to a single monster along with some general support can be obtained through this method.

Each player's deck consists of three monster cards and an additional fifty attack/defense/support cards. Monster cards start in play, have HP, and a type (either ground or air). Attack are always specific to one monster breed, defense cards can be specific to one monster breed, and support cards. To use these cards, a player usually has to pay an activation cost in the form of a resource called "guts".

The actual card game with both players, each with their three monsters on the field, flipping a coin to determine which player has the choice of going first or second. Each player then draws five cards. A player's turn consists of (in the following order):
A) A draw phase: The active player draws until he has five cards in hand)
B) A general phase: The active player can attack or use support cards. At this time the defending player can use defense cards to counter an opponent's attack)
C) The discard phase: The active player can discard any number of cards from their hand. Those discarded cards become "guts", which can be used to pay for attacks.

A monster is killed when its HP reaches 0. A player loses when they have no monsters remaining or when they are unable to draw a card.

The game consists of a character traveling to dungeons to obtain sacred stones needed to generate new monster cards and fighting ranked battles to increase their level to unlock new dungeons. Each dungeon contains multiple randomly generated floors, invisible guardians that automatically challenge the player, normal NPCs that the player can challenge, and a boss. After achieving the maximum rank and completing all the dungeons, a new dungeon is discovered and after defeating its boss a player has the option of starting a new game+ during which his normal deck is locked until he reaches the final dungeon. There's no actual story or objectives beyond unlocking content.

Reception
Reception
Aggregate score
AggregatorScore
GameRankings64%[1]
Review scores
PublicationScore
AllGame[2]
Famitsu22/40[3]
Game Informer6.75/10[4]
Nintendo Power6.4/10[5]

The game received "mixed" reviews according to the review aggregation website GameRankings.[1] In Japan, Famitsu gave it a score of 22 out of 40.[3]

gollark: > `globals()[Row + Row] = random.randint(*sys.version_info[:2])`Never actually got used anywhere.> `ε = sys.float_info.epsilon`Also not used. I just like epsilons.> `def __exit__(self, _, _________, _______):`This is also empty, because cleaning up the `_` global would be silly. It'll be overwritten anyway. This does serve a purpose, however, and not just in making it usable as a context manager. This actually swallows all errors, which is used in some places.> `def __pow__(self, m2):`As ever, this is not actual exponentiation. `for i, (ι, 𐌉) in enumerate(zip(self.bigData, m2.bigData)): e.bigData[i] = ι + 𐌉` is in fact just plain and simple addition of two matrices.> `def subtract(forth, 𝕒, polynomial, c, vector_space):`This just merges 4 submatrices back into one matrix.> `with out as out, out, forth:`Apart from capturing the exceptions, this doesn't really do much either. The `_` provided by the context manager is not used.> `_(0j, iｎt(0, 𝕒.n))`Yes, it's used in this line. However, this doesn't actually have any effect whatsoever on the execution of this. So I ignore it. It was merely a distraction.> `with Mаtrix(ℤ(ℤ(4))):`It is used again to swallow exceptions. After this is just some fluff again.> `def strassen(m, x= 3.1415935258989):`This is an interesting part. Despite being called `strassen`, it does not actually implement the Strassen algorithm, which is a somewhat more efficient way to multiply matrices than the naive way used in - as far as I can tell - every entry.> `e = 2 ** (math.ceil(math.log2(m.n)) - 1)`This gets the next power of two in a fairly obvious way. It is used to pad out the matrix to the next power of 2 size.> `with m:`The context manager is used again for nicer lookups.> `Result[0] += [_(0j, iｎt(e, e))]`Weird pythonoquirkiness again. You can append to lists in tuples with `+=`, but it throws an exception as they're sort of immutable.> `typing(lookup[4])(input())`It's entirely possible that this does things.
gollark: > `def __eq__(self, xy): return self.bigData[math.floor(xy.real * self.n + xy.imag)]`This actually gets indices into the matrix. I named it badly for accursedness. It uses complex number coordinates.> `def __matmul__(self, ǫ):`*This* function gets a 2D "slice" of the matrix between the specified coordinates. > `for (fοr, k), (b, р), (whіle, namedtuple) in itertools.product(I(*iｎt.ℝ(start, end)), enumerate(range(ℤ(start.imag), math.floor(end.imag))), (ǫ, ǫ)):`This is really just bizarre obfuscation for the basic "go through every X/Y in the slice" thing.> `out[b * 1j + fοr] = 0`In case the matrix is too big, just pad it with zeros.> `except ZeroDivisionError:`In case of zero divisions, which cannot actually *happen*, we replace 0 with 1 except this doesn't actually work.> `import hashlib`As ever, we need hashlib.> `memmove(id(0), id(1), 27)`It *particularly* doesn't work because we never imported this name.> `def __setitem__(octonion, self, v):`This sets either slices or single items of the matrix. I would have made it use a cool™️ operator, but this has three parameters, unlike the other ones. It's possible that I could have created a temporary "thing setting handle" or something like that and used two operators, but I didn't.> `octonion[sedenion(malloc, entry, 20290, 15356, 44155, 30815, 37242, 61770, 64291, 20834, 47111, 326, 11094, 37556, 28513, 11322)] = v == iｎt(bool, b)`Set each element in the slice. The sharp-eyed may wonder where `sedenion` comes from.> `"""`> `for testing`> `def __repr__(m):`This was genuinely for testing, although the implementation here was more advanced.> `def __enter__(The_Matrix: 2):`This allows use of `Matrix` objects as context managers.> `globals()[f"""_"""] = lambda h, Ĥ: The_Matrix@(h,Ĥ)`This puts the matrix slicing thing into a convenient function accessible globally (as long as the context manager is running). This is used a bit below.
gollark: * desired
gollark: I can write some code for this if desisred.
gollark: Surely you can just pull a particular tag of the container.

References
  1. "Monster Rancher Battle Card GB for Game Boy Color". GameRankings. CBS Interactive. Archived from the original on May 22, 2019. Retrieved June 17, 2020.
  2. Huey, Christian. "Monster Rancher: Battle Card GB - Review". AllGame. All Media Network. Archived from the original on November 15, 2014. Retrieved June 5, 2016.
  3. "モンスターファーム バトルカードGB [ゲームボーイ]". Famitsu (in Japanese). Enterbrain. Retrieved June 17, 2020.
  4. "Monster Rancher Battle Card [GB]". Game Informer. No. 87. FuncoLand. July 2000.
  5. "Monster Rancher Battle Card Game". Nintendo Power. Vol. 132. Nintendo of America. May 2000. p. 128.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.