joker.h

Go to the documentation of this file.

 
#ifndef JOKER_H
#define JOKER_H
 
#include "card.h"
#include "game.h"
#include "graphic_utils.h"
#include "item.h"
#include "random.h"
 
#include <maxmod.h>
 
#define MAX_DEFINABLE_JOKERS 150
 
// Pack the enum into a u8 so that the Joker struct uses as little memory as possible
enum JokerRarity : u8
{
    COMMON_JOKER,
    UNCOMMON_JOKER,
    RARE_JOKER,
    LEGENDARY_JOKER,
    MAX_RARITIES
};
 
// Percent chance to get a joker of each rarity
// Note that this deviates slightly from the Balatro wiki to allow legendary
// jokers to appear without spectral cards implemented
#define COMMON_JOKER_CHANCE    70
#define UNCOMMON_JOKER_CHANCE  25
#define RARE_JOKER_CHANCE      5
#define LEGENDARY_JOKER_CHANCE 0
 
// These are the common Joker Events. Special Joker behaviour will be checked on a
// Joker per Joker basis (see if it's there, then do something, e.g. Pareidolia, Baseball Card)
enum JokerEvent
{
    JOKER_EVENT_ON_JOKER_CREATED, // Triggers only once when the Joker is created, mainly used for
                                  // data initialization
    JOKER_EVENT_ON_HAND_PLAYED,   // Triggers only once when the hand is played and before the cards
                                  // are scored
    JOKER_EVENT_ON_CARD_SCORED,   // Triggers when a played card scores (e.g. Walkie Talkie,
                                  // Fibonnacci...)
    JOKER_EVENT_ON_CARD_SCORED_END, // Triggers after the card has finishd scoring (e.g. retrigger
                                    // Jokers)
    JOKER_EVENT_ON_CARD_HELD,       // Triggers when going through held cards
    JOKER_EVENT_INDEPENDENT, // Joker will trigger normally, when Jokers are scored (e.g. base
                             // Joker)
    JOKER_EVENT_ON_HAND_SCORED_END, // Triggers when entire hand has finished scoring (e.g. food
                                    // Jokers)
    JOKER_EVENT_ON_HAND_DISCARDED,  // Triggers when discarding a hand
    JOKER_EVENT_ON_ROUND_END,       // Triggers at the end of the round (e.g. Rocket)
    JOKER_EVENT_ON_BLIND_SELECTED,  // Triggers when selecting a blind (e.g. Dagger, Riff Raff,
                                    // Madness..)
};
 
// These are flags that can be combined into a single u32 and returned by
// JokerEffect functions to indicate which fields of the output JokerEffect are valid
 
#define JOKER_EFFECT_FLAG_NONE      0
#define JOKER_EFFECT_FLAG_CHIPS     (1 << 0)
#define JOKER_EFFECT_FLAG_MULT      (1 << 1)
#define JOKER_EFFECT_FLAG_XMULT     (1 << 2)
#define JOKER_EFFECT_FLAG_MONEY     (1 << 3)
#define JOKER_EFFECT_FLAG_RETRIGGER (1 << 4)
#define JOKER_EFFECT_FLAG_EXPIRE    (1 << 5)
#define JOKER_EFFECT_FLAG_MESSAGE   (1 << 6)
 
#define MAX_JOKER_OBJECTS 32 // The maximum number of joker objects that can be created at once
 
// Jokers in the game
#define STENCIL_JOKER_ID      15
#define SHORTCUT_JOKER_ID     48
#define BRAINSTORM_JOKER_ID   41
#define PAREIDOLIA_JOKER_ID   46
#define FOUR_FINGERS_JOKER_ID 50
#define BLUEPRINT_JOKER_ID    52
 
typedef struct
{
    u8 id; // Unique ID for the joker, used to identify different jokers
    u8 value;
    enum JokerRarity rarity;
 
    // General purpose values that are interpreted differently for each Joker (scaling, last
    // retriggered card, etc...)
    s32 scoring_state;
    s32 persistent_state;
} Joker;
 
typedef struct JokerObject
{
    Item; // First member struct inheritance
    Joker* joker;
} JokerObject;
 
typedef struct // These jokers are triggered after the played hand has finished scoring.
{
    u32 chips;
    u32 mult;
    u32 xmult;
    int money;
    bool retrigger; // Retrigger played hand (e.g. "Dusk" joker, even though on the wiki it says "On
                    // Scored" it makes more sense to have it here)
    bool expire;    // Will make the Joker expire/destry itself if true (i.e. Bananas and fully
                    // consumed Food Jokers)
    char* message;  // Used to send custom messages e.g. "Extinct!" or "Again!"
} JokerEffect;
 
// JokerEffectFuncs take in a joker that will be scored, a scored_card that is not NULL when related
// to the given joker_event, and output a joker_effect storing the effects of the scored joker They
// return a set of flags indicating what fields of the joker_effect are valid to access
typedef u32 (*JokerEffectFunc)(
    Joker* joker,
    Card* scored_card,
    enum JokerEvent joker_event,
    JokerEffect** joker_effect
);
 
typedef int (*JokerDescFunc)(Joker* joker, Rect dest_rect);
 
typedef struct
{
    const char* name;
    enum JokerRarity rarity;
    u8 base_value;
    bool is_desc_dynamic; // Is the little variable description at the bottom dynamic?
                          // Only used by the Misprint joker for now
    JokerDescFunc joker_print_desc;
    JokerEffectFunc joker_effect_func;
} JokerInfo;
const JokerInfo* get_joker_registry_entry(int joker_id);
size_t get_joker_registry_size(void);
 
void joker_init();
 
Joker* joker_new(u8 id);
void joker_destroy(Joker** joker);
 
// Unique effects like "Four Fingers" or "Credit Card" will be hard coded into game.c with a
// conditional check for the joker ID from the players owned jokers game.c should probably be
// restructured so most of the variables in it are moved to some sort of global variable header file
// so they can be easily accessed and modified for the jokers
u32 joker_get_score_effect(
    Joker* joker,
    Card* scored_card,
    enum JokerEvent joker_event,
    JokerEffect** joker_effect
);
 
int joker_get_sell_value(const Joker* joker);
 
int joker_get_buy_price(const Joker* joker);
 
const char* joker_object_get_name(Item* joker_object);
 
ItemDescSubtypeInfo joker_object_get_rarity_info(Item* joker_object);
 
JokerObject* joker_object_new(Joker* joker);
void joker_object_destroy(JokerObject** joker_object);
// This doesn't actually score anything, it just performs an animation and plays a sound effect
void joker_object_shake(JokerObject* joker_object, mm_word sound_id);
 
int joker_object_get_buy_price(Item* joker_object);
 
int joker_object_get_sell_price(Item* joker_object);
 
// TODO: Move to an owned_jokers.c/.h file?
void joker_object_add_to_owned(Item* joker_object);
 
void joker_object_dispose(Item** joker_object);
 
int joker_object_print_description(Item* joker_object, Rect dest_rect);
 
int joker_roll_id_with_rarity(int joker_rarity);
 
int joker_roll_id(enum JokerRarity joker_rarity, enum RngSequence key);
 
void joker_set_rollable(int joker_id, bool rollable);
 
void joker_reset_rollable_jokers(void);
 
Item* joker_object_roll_new(enum RngSequence key);
 
Sprite* joker_object_get_sprite(JokerObject* joker_object);
 
#endif // JOKER_H