Shadowtrance
497 lines
16 KiB
C++
497 lines
16 KiB
C++
/**
|
|
* @file PetLogic.cpp
|
|
* @brief Game logic implementation for TamaTac
|
|
*/
|
|
|
|
#include "PetLogic.h"
|
|
#include <TactilityCpp/Preferences.h>
|
|
#include <cstdlib>
|
|
#include <algorithm>
|
|
|
|
// Static member initialization (2 = normal 1x speed)
|
|
uint8_t PetLogic::decayMultiplier = 2;
|
|
|
|
void PetLogic::setDecaySpeed(uint8_t speed) {
|
|
// speed: 0=slow, 1=normal, 2=fast
|
|
// multiplier: 1=0.5x, 2=1x, 4=2x
|
|
switch (speed) {
|
|
case 0: decayMultiplier = 1; break; // Slow (0.5x)
|
|
case 1: decayMultiplier = 2; break; // Normal (1x)
|
|
case 2: decayMultiplier = 4; break; // Fast (2x)
|
|
default: decayMultiplier = 2; break;
|
|
}
|
|
}
|
|
|
|
PetLogic::PetLogic() {
|
|
stats = PetStats();
|
|
stats.lastUpdateTime = tt::kernel::getMillis();
|
|
}
|
|
|
|
void PetLogic::update(uint32_t currentTimeMs) {
|
|
if (stats.isDead) {
|
|
return;
|
|
}
|
|
|
|
// Calculate elapsed time since last update
|
|
uint32_t elapsedMs = currentTimeMs - stats.lastUpdateTime;
|
|
uint32_t elapsedSeconds = elapsedMs / 1000;
|
|
|
|
// Only advance lastUpdateTime by counted milliseconds to preserve sub-second remainder
|
|
stats.lastUpdateTime += elapsedSeconds * 1000;
|
|
|
|
if (elapsedSeconds == 0) {
|
|
return; // Nothing to update yet
|
|
}
|
|
|
|
// Update age
|
|
stats.ageSeconds += elapsedSeconds;
|
|
stats.lifespan += elapsedSeconds;
|
|
stats.ageHours = static_cast<uint16_t>(stats.ageSeconds / 3600);
|
|
|
|
// Reset transient action animations (eating, playing, happy) back to idle
|
|
// These are set by actions and should only persist until the next update tick
|
|
if (stats.currentAnim == AnimState::Eating ||
|
|
stats.currentAnim == AnimState::Playing ||
|
|
stats.currentAnim == AnimState::Happy) {
|
|
stats.currentAnim = AnimState::Idle;
|
|
}
|
|
|
|
// Apply time-based stat decay
|
|
applyStatDecay(elapsedSeconds);
|
|
|
|
// Check health status
|
|
checkHealth();
|
|
|
|
// Check evolution
|
|
checkEvolution();
|
|
|
|
// Random poop
|
|
randomPoopCheck();
|
|
|
|
// Random events
|
|
checkRandomEvent();
|
|
}
|
|
|
|
void PetLogic::performAction(PetAction action) {
|
|
if (stats.isDead) {
|
|
return;
|
|
}
|
|
|
|
// Wake up from sleep when performing any action (except Sleep itself)
|
|
if (action != PetAction::Sleep && stats.isAsleep) {
|
|
stats.isAsleep = false;
|
|
stats.currentAnim = AnimState::Idle;
|
|
}
|
|
|
|
switch (action) {
|
|
case PetAction::Feed:
|
|
feed();
|
|
break;
|
|
case PetAction::Play:
|
|
play();
|
|
break;
|
|
case PetAction::Medicine:
|
|
giveMedicine();
|
|
break;
|
|
case PetAction::Sleep:
|
|
sleep();
|
|
break;
|
|
case PetAction::Clean:
|
|
clean();
|
|
break;
|
|
case PetAction::Pet:
|
|
pet();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void PetLogic::feed() {
|
|
uint32_t now = tt::kernel::getMillis();
|
|
|
|
stats.hunger = clampStat(stats.hunger + ActionEffects::FEED_HUNGER_GAIN);
|
|
stats.happiness = clampStat(stats.happiness - ActionEffects::FEED_HAPPINESS_LOSS);
|
|
|
|
if (rand() % 100 < ActionEffects::FEED_POOP_CHANCE) {
|
|
addPoop();
|
|
}
|
|
|
|
if (stats.poopCount > 0) {
|
|
stats.cleanliness = clampStat(100 - (stats.poopCount * 30));
|
|
}
|
|
|
|
stats.lastFeedTime = now;
|
|
stats.currentAnim = AnimState::Eating;
|
|
}
|
|
|
|
void PetLogic::play() {
|
|
uint32_t now = tt::kernel::getMillis();
|
|
|
|
stats.happiness = clampStat(stats.happiness + ActionEffects::PLAY_HAPPINESS_GAIN);
|
|
stats.energy = clampStat(stats.energy - ActionEffects::PLAY_ENERGY_LOSS);
|
|
stats.hunger = clampStat(stats.hunger - ActionEffects::PLAY_HUNGER_LOSS);
|
|
|
|
stats.lastPlayTime = now;
|
|
stats.currentAnim = AnimState::Playing;
|
|
}
|
|
|
|
void PetLogic::giveMedicine() {
|
|
if (stats.isSick) {
|
|
stats.isSick = false;
|
|
stats.health = clampStat(stats.health + ActionEffects::MEDICINE_HEALTH_GAIN);
|
|
stats.currentAnim = AnimState::Idle;
|
|
} else {
|
|
stats.health = clampStat(stats.health + ActionEffects::MEDICINE_HEALTH_BOOST);
|
|
}
|
|
}
|
|
|
|
void PetLogic::sleep() {
|
|
stats.energy = clampStat(stats.energy + ActionEffects::SLEEP_ENERGY_GAIN);
|
|
stats.happiness = clampStat(stats.happiness - ActionEffects::SLEEP_HAPPINESS_LOSS);
|
|
|
|
stats.isAsleep = true;
|
|
stats.currentAnim = AnimState::Sleeping;
|
|
}
|
|
|
|
void PetLogic::clean() {
|
|
if (stats.poopCount > 0) {
|
|
stats.poopCount = 0;
|
|
stats.cleanliness = PetThresholds::STAT_MAX;
|
|
stats.happiness = clampStat(stats.happiness + 10);
|
|
}
|
|
}
|
|
|
|
void PetLogic::pet() {
|
|
stats.happiness = clampStat(stats.happiness + ActionEffects::PET_HAPPINESS_GAIN);
|
|
stats.currentAnim = AnimState::Happy;
|
|
}
|
|
|
|
void PetLogic::applyPlayResult(int roundsCompleted, int maxRounds) {
|
|
if (stats.isDead) return;
|
|
|
|
if (stats.isAsleep) {
|
|
stats.isAsleep = false;
|
|
stats.currentAnim = AnimState::Idle;
|
|
}
|
|
|
|
if (maxRounds > 0 && roundsCompleted >= maxRounds) {
|
|
// Full win: generous reward
|
|
stats.happiness = clampStat(stats.happiness + 30);
|
|
stats.energy = clampStat(stats.energy - 10);
|
|
stats.hunger = clampStat(stats.hunger - 5);
|
|
} else if (roundsCompleted > 0) {
|
|
// Partial: scaled reward
|
|
stats.happiness = clampStat(stats.happiness + 10 + roundsCompleted * 5);
|
|
stats.energy = clampStat(stats.energy - 5);
|
|
} else {
|
|
// Lost immediately: token reward
|
|
stats.happiness = clampStat(stats.happiness + 5);
|
|
stats.energy = clampStat(stats.energy - 5);
|
|
}
|
|
|
|
stats.currentAnim = AnimState::Playing;
|
|
stats.lastPlayTime = tt::kernel::getMillis();
|
|
}
|
|
|
|
void PetLogic::applyStatDecay(uint32_t elapsedSeconds) {
|
|
uint32_t ticks = elapsedSeconds / DecayRates::TICK_INTERVAL_SEC;
|
|
if (ticks == 0) return;
|
|
|
|
// Cap ticks to prevent extreme decay after very long absence
|
|
if (ticks > 100) ticks = 100;
|
|
|
|
// Apply decay multiplier (1=slow 0.5x, 2=normal 1x, 4=fast 2x)
|
|
// We multiply ticks by decayMultiplier/2 to get effective ticks
|
|
uint32_t effectiveTicks = (ticks * decayMultiplier) / 2;
|
|
if (effectiveTicks == 0 && ticks > 0) effectiveTicks = 1; // At least 1 tick if time passed
|
|
|
|
for (uint32_t i = 0; i < effectiveTicks; i++) {
|
|
stats.hunger = clampStat(stats.hunger - DecayRates::HUNGER_DECAY);
|
|
stats.happiness = clampStat(stats.happiness - DecayRates::HAPPINESS_DECAY);
|
|
stats.energy = clampStat(stats.energy - DecayRates::ENERGY_DECAY);
|
|
|
|
if (stats.hunger < PetThresholds::HUNGRY_THRESHOLD ||
|
|
stats.happiness < PetThresholds::UNHAPPY_THRESHOLD) {
|
|
stats.health = clampStat(stats.health - DecayRates::HEALTH_DECAY_NEGLECT);
|
|
}
|
|
}
|
|
|
|
// Apply personality and day/night modifiers (per tick)
|
|
DayPhase phase = getDayPhase();
|
|
for (uint32_t i = 0; i < effectiveTicks; i++) {
|
|
// Personality modifiers
|
|
switch (stats.personality) {
|
|
case Personality::Energetic:
|
|
stats.energy = clampStat(stats.energy + 1);
|
|
stats.hunger = clampStat(stats.hunger - 1);
|
|
break;
|
|
case Personality::Lazy:
|
|
stats.energy = clampStat(stats.energy - 1);
|
|
stats.happiness = clampStat(stats.happiness + 1);
|
|
break;
|
|
case Personality::Glutton:
|
|
stats.hunger = clampStat(stats.hunger - 1);
|
|
stats.cleanliness = clampStat(stats.cleanliness - 1);
|
|
break;
|
|
case Personality::Cheerful:
|
|
stats.happiness = clampStat(stats.happiness + 1);
|
|
stats.energy = clampStat(stats.energy - 1);
|
|
break;
|
|
case Personality::Hardy:
|
|
stats.health = clampStat(stats.health + 1);
|
|
stats.hunger = clampStat(stats.hunger - 1);
|
|
break;
|
|
}
|
|
// Day/night modifiers
|
|
if (phase == DayPhase::Day) {
|
|
stats.energy = clampStat(stats.energy - 1); // More active during day
|
|
} else {
|
|
stats.hunger = clampStat(stats.hunger - 1); // Metabolism at night
|
|
// Auto-sleep if energy critically low at night
|
|
if (!stats.isAsleep && stats.energy < PetThresholds::TIRED_THRESHOLD) {
|
|
stats.isAsleep = true;
|
|
stats.currentAnim = AnimState::Sleeping;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (stats.poopCount > 0) {
|
|
stats.cleanliness = clampStat(100 - (stats.poopCount * 30));
|
|
}
|
|
}
|
|
|
|
void PetLogic::checkHealth() {
|
|
if (stats.health < PetThresholds::SICK_THRESHOLD && !stats.isDead) {
|
|
stats.isSick = true;
|
|
}
|
|
|
|
if (stats.health <= 0) {
|
|
stats.isDead = true;
|
|
stats.isSick = false;
|
|
stats.stage = LifeStage::Ghost;
|
|
stats.currentAnim = AnimState::Dead;
|
|
}
|
|
}
|
|
|
|
void PetLogic::checkEvolution() {
|
|
if (stats.isDead) {
|
|
return;
|
|
}
|
|
|
|
LifeStage newStage = stats.stage;
|
|
|
|
if (stats.ageHours < 1) {
|
|
newStage = LifeStage::Egg;
|
|
} else if (stats.ageHours < 8) {
|
|
newStage = LifeStage::Baby;
|
|
} else if (stats.ageHours < 24) {
|
|
newStage = LifeStage::Teen;
|
|
} else if (stats.ageHours < 72) {
|
|
newStage = LifeStage::Adult;
|
|
} else {
|
|
newStage = LifeStage::Elder;
|
|
}
|
|
|
|
if (newStage != stats.stage) {
|
|
stats.stage = newStage;
|
|
}
|
|
}
|
|
|
|
DayPhase PetLogic::getDayPhase() const {
|
|
return (stats.ageSeconds % 3600 < 1800) ? DayPhase::Day : DayPhase::Night;
|
|
}
|
|
|
|
AnimState PetLogic::getCurrentAnimation() const {
|
|
if (stats.isDead) {
|
|
return AnimState::Dead;
|
|
}
|
|
|
|
if (stats.isAsleep) {
|
|
return AnimState::Sleeping;
|
|
}
|
|
|
|
if (stats.isSick) {
|
|
return AnimState::Sick;
|
|
}
|
|
|
|
if (stats.happiness < PetThresholds::UNHAPPY_THRESHOLD) {
|
|
return AnimState::Sad;
|
|
}
|
|
|
|
return stats.currentAnim;
|
|
}
|
|
|
|
|
|
void PetLogic::randomPoopCheck() {
|
|
if (rand() % 1000 < 10) {
|
|
addPoop();
|
|
}
|
|
}
|
|
|
|
void PetLogic::addPoop() {
|
|
if (stats.poopCount < 3) {
|
|
stats.poopCount++;
|
|
}
|
|
}
|
|
|
|
RandomEvent PetLogic::checkRandomEvent() {
|
|
if (stats.isDead || stats.isAsleep) return RandomEvent::None;
|
|
if (rand() % 100 >= 12) return RandomEvent::None; // 12% chance per tick
|
|
|
|
// Build eligible events based on current state
|
|
RandomEvent eligible[6];
|
|
int count = 0;
|
|
|
|
if (stats.hunger < 85) eligible[count++] = RandomEvent::FoundTreat;
|
|
if (stats.happiness < 85) eligible[count++] = RandomEvent::MadeFriend;
|
|
if (!stats.isSick && stats.health > 30) eligible[count++] = RandomEvent::CaughtCold;
|
|
if (stats.cleanliness > 30) eligible[count++] = RandomEvent::GotMuddy;
|
|
if (stats.energy < 85) eligible[count++] = RandomEvent::HadNap;
|
|
if (getDayPhase() == DayPhase::Day && stats.happiness < 90) eligible[count++] = RandomEvent::SunnyDay;
|
|
|
|
if (count == 0) return RandomEvent::None;
|
|
|
|
RandomEvent event = eligible[rand() % count];
|
|
|
|
// Apply effects
|
|
switch (event) {
|
|
case RandomEvent::FoundTreat:
|
|
stats.hunger = clampStat(stats.hunger + 15);
|
|
break;
|
|
case RandomEvent::MadeFriend:
|
|
stats.happiness = clampStat(stats.happiness + 15);
|
|
break;
|
|
case RandomEvent::CaughtCold:
|
|
stats.isSick = true;
|
|
stats.health = clampStat(stats.health - 10);
|
|
break;
|
|
case RandomEvent::GotMuddy:
|
|
stats.cleanliness = clampStat(stats.cleanliness - 20);
|
|
break;
|
|
case RandomEvent::HadNap:
|
|
stats.energy = clampStat(stats.energy + 15);
|
|
break;
|
|
case RandomEvent::SunnyDay:
|
|
stats.happiness = clampStat(stats.happiness + 10);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
stats.lastEvent = event;
|
|
return event;
|
|
}
|
|
|
|
uint8_t PetLogic::clampStat(int16_t value) {
|
|
if (value < PetThresholds::STAT_MIN) {
|
|
return PetThresholds::STAT_MIN;
|
|
}
|
|
if (value > PetThresholds::STAT_MAX) {
|
|
return PetThresholds::STAT_MAX;
|
|
}
|
|
return static_cast<uint8_t>(value);
|
|
}
|
|
|
|
void PetLogic::saveState() {
|
|
Preferences prefs("TamaTac");
|
|
|
|
prefs.putInt32("hunger", stats.hunger);
|
|
prefs.putInt32("happiness", stats.happiness);
|
|
prefs.putInt32("health", stats.health);
|
|
prefs.putInt32("energy", stats.energy);
|
|
|
|
prefs.putInt32("cleanliness", stats.cleanliness);
|
|
prefs.putInt32("poopCount", stats.poopCount);
|
|
|
|
prefs.putInt32("ageSeconds", stats.ageSeconds);
|
|
prefs.putInt32("ageHours", stats.ageHours);
|
|
prefs.putInt32("lifespan", stats.lifespan);
|
|
|
|
prefs.putBool("isSick", stats.isSick);
|
|
prefs.putBool("isAsleep", stats.isAsleep);
|
|
prefs.putBool("isDead", stats.isDead);
|
|
|
|
prefs.putInt32("stage", static_cast<int32_t>(stats.stage));
|
|
prefs.putInt32("currentAnim", static_cast<int32_t>(stats.currentAnim));
|
|
prefs.putInt32("personality", static_cast<int32_t>(stats.personality));
|
|
|
|
// Note: uint32_t millis stored as int32_t (Preferences API limitation).
|
|
// Two's complement round-trips correctly; no unsigned API available.
|
|
prefs.putInt32("lastSaveTime", static_cast<int32_t>(tt::kernel::getMillis()));
|
|
}
|
|
|
|
bool PetLogic::loadState() {
|
|
Preferences prefs("TamaTac");
|
|
|
|
// Check if save data exists
|
|
int32_t savedHunger = prefs.getInt32("hunger", -1);
|
|
if (savedHunger == -1) {
|
|
return false;
|
|
}
|
|
|
|
// Clamp loaded values to valid ranges (guard against corrupted preferences)
|
|
stats.hunger = clampStat(savedHunger);
|
|
stats.happiness = clampStat(prefs.getInt32("happiness", 70));
|
|
stats.health = clampStat(prefs.getInt32("health", 100));
|
|
stats.energy = clampStat(prefs.getInt32("energy", 90));
|
|
|
|
stats.cleanliness = clampStat(prefs.getInt32("cleanliness", 100));
|
|
int32_t loadedPoopCount = prefs.getInt32("poopCount", 0);
|
|
stats.poopCount = (loadedPoopCount < 0) ? 0 : (loadedPoopCount > 3) ? 3 : static_cast<uint8_t>(loadedPoopCount);
|
|
|
|
// uint32_t fields stored as int32_t (Preferences API limitation); cast back explicitly
|
|
stats.ageSeconds = static_cast<uint32_t>(prefs.getInt32("ageSeconds", 0));
|
|
stats.ageHours = static_cast<uint16_t>(prefs.getInt32("ageHours", 0));
|
|
stats.lifespan = static_cast<uint32_t>(prefs.getInt32("lifespan", 0));
|
|
|
|
stats.isSick = prefs.getBool("isSick", false);
|
|
stats.isAsleep = prefs.getBool("isAsleep", false);
|
|
stats.isDead = prefs.getBool("isDead", false);
|
|
|
|
int32_t loadedStage = prefs.getInt32("stage", static_cast<int32_t>(LifeStage::Egg));
|
|
if (loadedStage < 0 || loadedStage > static_cast<int32_t>(LifeStage::Ghost)) {
|
|
loadedStage = static_cast<int32_t>(LifeStage::Egg);
|
|
}
|
|
stats.stage = static_cast<LifeStage>(loadedStage);
|
|
|
|
int32_t loadedAnim = prefs.getInt32("currentAnim", static_cast<int32_t>(AnimState::Idle));
|
|
if (loadedAnim < 0 || loadedAnim > static_cast<int32_t>(AnimState::Dead)) {
|
|
loadedAnim = static_cast<int32_t>(AnimState::Idle);
|
|
}
|
|
stats.currentAnim = static_cast<AnimState>(loadedAnim);
|
|
|
|
int32_t loadedPersonality = prefs.getInt32("personality", 0);
|
|
if (loadedPersonality < 0 || loadedPersonality > static_cast<int32_t>(Personality::Hardy)) {
|
|
loadedPersonality = 0;
|
|
}
|
|
stats.personality = static_cast<Personality>(loadedPersonality);
|
|
|
|
// Handle time elapsed since last save
|
|
uint32_t lastSaveTime = prefs.getInt32("lastSaveTime", 0);
|
|
uint32_t currentTime = tt::kernel::getMillis();
|
|
|
|
if (lastSaveTime > 0 && currentTime > lastSaveTime) {
|
|
uint32_t elapsedMs = currentTime - lastSaveTime;
|
|
uint32_t elapsedSeconds = elapsedMs / 1000;
|
|
|
|
stats.ageSeconds += elapsedSeconds;
|
|
stats.lifespan += elapsedSeconds;
|
|
stats.ageHours = static_cast<uint16_t>(stats.ageSeconds / 3600);
|
|
|
|
// Apply time-based decay for time away
|
|
applyStatDecay(elapsedSeconds);
|
|
|
|
checkHealth();
|
|
checkEvolution();
|
|
}
|
|
|
|
stats.lastUpdateTime = currentTime;
|
|
|
|
return true;
|
|
}
|
|
|
|
void PetLogic::reset() {
|
|
stats = PetStats();
|
|
stats.personality = static_cast<Personality>(rand() % 5);
|
|
stats.lastUpdateTime = tt::kernel::getMillis();
|
|
}
|