celeste.cpp

/*
 * This is where the actual celeste code sits.
 * It is mostly a line by line port of the original lua code.
 * Due to C limitations, modifications have to be made, mostly relating to static typing.
 * The PICO-8 functions such as music() are used here preceded by Celeste_P8,
 * so _init becomes Celeste_P8_init && music becomes P8music, etc
 */

#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>

#include "celeste.h"

#if defined (__NGAGE__) || defined (NGAGE_DEBUG) || defined(__XBOX__)
#include <SDL2/SDL.h>
#define snprintf SDL_snprintf
#endif

#if defined CELESTE_P8_FIXEDP

//very ugly hack:
//in order to switch to fixed point type and arithmetic, without having
//to replace every arithmetic operator with a macro call, use a C++
//struct with operator overloading and #define float to it...
//it works, i guess!

# ifndef __cplusplus
#  error "fixed point mode can only be compiled with a C++ compiler"
# endif
#include <cstdint>
#include <climits>
struct _fix32 {
    int32_t n;
    static const int32_t FACTOR = (1<<16);

    //constructor
    template <typename T> _fix32(T v) { *this = v; /* use operator= */ }
    _fix32() { /*undefined*/ }

    //construct number from raw integer value
    static _fix32 from_bits(int32_t i) {
        _fix32 tmp;
        tmp.n = i;
        return tmp;
    }

    //fractional part
    inline uint16_t frac() { return static_cast<uint16_t>(this->n); }

    // T -> _fix32
    template <typename T> static inline _fix32 from(T n) { return _fix32::from_bits(n * T(FACTOR)); }
    // _fix32 -> T
    template <typename T> inline T to() const { return T(this->n) / T(FACTOR); }

    template <typename T> inline _fix32& operator=(T n) {
        this->n = _fix32::from<T>(n).n;
        return *this;
    }

    //same as .to<T>()
        template <typename T> inline explicit operator T() const { return this->to<T>(); }

    //arithmetic operator overloading
    inline friend _fix32 operator +(_fix32 a, _fix32 b) { return from_bits(a.n + b.n); }
    inline friend _fix32 operator -(_fix32 a, _fix32 b) { return from_bits(a.n - b.n); }
    inline friend _fix32 operator -(_fix32 a) { return from_bits(-a.n); }
    inline friend _fix32 operator *(_fix32 a, _fix32 b) {
        return from_bits(int64_t(a.n)*int64_t(b.n) / int64_t(FACTOR));
    }
    inline friend _fix32 operator /(_fix32 a, _fix32 b) { //pico8 decomp'd
        if (b == 0) return a > 0 ? FACTOR : -FACTOR; // +inf / -inf
        if (b.frac() == 0 && ((int)b > 0)) {
            return _fix32::from_bits(int64_t(a.n) / int64_t(b));
        }
        return from_bits((int64_t(a.n)*FACTOR) / int64_t(b.n));
    }

    inline friend _fix32& operator +=(_fix32& a, _fix32 b) { return a = a + b; }
    inline friend _fix32& operator -=(_fix32& a, _fix32 b) { return a = a - b; }
    inline friend _fix32& operator *=(_fix32& a, _fix32 b) { return a = a * b; }
    inline friend _fix32& operator /=(_fix32& a, _fix32 b) { return a = a / b; }
    inline friend bool operator ==(_fix32 a, _fix32 b) { return a.n == b.n; }
    inline friend bool operator !=(_fix32 a, _fix32 b) { return a.n != b.n; }
    inline friend bool operator  <(_fix32 a, _fix32 b) { return a.n < b.n; }
    inline friend bool operator  >(_fix32 a, _fix32 b) { return a.n > b.n; }
    inline friend bool operator <=(_fix32 a, _fix32 b) { return a.n <= b.n; }
    inline friend bool operator >=(_fix32 a, _fix32 b) { return a.n >= b.n; }

};
static_assert(sizeof(_fix32) == 4, "bad");

//math functions
static _fix32 _fix32_mod(_fix32 a, _fix32 b) {
    return _fix32::from_bits(((a.n % b.n) + b.n) % b.n);
}
static _fix32 _fix32_sin(_fix32 x) { //pico8 decomp'd
    static const int32_t sin_tbl[4098] = {65536,65536,65536,65536,65536,65536,65536,65536,65536,65536,65536,65535,65535,65535,65535,65535,65535,65535,65534,65534,65534,65534,65534,65533,65533,65533,65533,65532,65532,65532,65532,65531,65531,65531,65530,65530,65530,65529,65529,65529,65528,65528,65527,65527,65527,65526,65526,65525,65525,65524,65524,65523,65523,65522,65522,65521,65521,65520,65520,65519,65519,65518,65517,65517,65516,65516,65515,65514,65514,65513,65512,65512,65511,65510,65510,65509,65508,65507,65507,65506,65505,65504,65504,65503,65502,65501,65500,65500,65499,65498,65497,65496,65495,65494,65493,65493,65492,65491,65490,65489,65488,65487,65486,65485,65484,65483,65482,65481,65480,65479,65478,65477,65476,65474,65473,65472,65471,65470,65469,65468,65467,65465,65464,65463,65462,65461,65460,65458,65457,65456,65455,65453,65452,65451,65449,65448,65447,65446,65444,65443,65442,65440,65439,65437,65436,65435,65433,65432,65430,65429,65428,65426,65425,65423,65422,65420,65419,65417,65416,65414,65413,65411,65410,65408,65406,65405,65403,65402,65400,65398,65397,65395,65393,65392,65390,65388,65387,65385,65383,65382,65380,65378,65376,65375,65373,65371,65369,65368,65366,65364,65362,65360,65358,65357,65355,65353,65351,65349,65347,65345,65343,65341,65339,65338,65336,65334,65332,65330,65328,65326,65324,65322,65320,65317,65315,65313,65311,65309,65307,65305,65303,65301,65299,65296,65294,65292,65290,65288,65286,65283,65281,65279,65277,65275,65272,65270,65268,65265,65263,65261,65259,65256,65254,65252,65249,65247,65245,65242,65240,65237,65235,65233,65230,65228,65225,65223,65220,65218,65215,65213,65210,65208,65205,65203,65200,65198,65195,65193,65190,65188,65185,65182,65180,65177,65175,65172,65169,65167,65164,65161,65159,65156,65153,65150,65148,65145,65142,65139,65137,65134,65131,65128,65126,65123,65120,65117,65114,65111,65109,65106,65103,65100,65097,65094,65091,65088,65085,65082,65079,65076,65073,65070,65067,65064,65061,65058,65055,65052,65049,65046,65043,65040,65037,65034,65031,65028,65025,65021,65018,65015,65012,65009,65006,65002,64999,64996,64993,64989,64986,64983,64980,64976,64973,64970,64967,64963,64960,64957,64953,64950,64947,64943,64940,64936,64933,64930,64926,64923,64919,64916,64912,64909,64905,64902,64899,64895,64892,64888,64884,64881,64877,64874,64870,64867,64863,64859,64856,64852,64849,64845,64841,64838,64834,64830,64827,64823,64819,64816,64812,64808,64804,64801,64797,64793,64789,64786,64782,64778,64774,64770,64766,64763,64759,64755,64751,64747,64743,64739,64735,64732,64728,64724,64720,64716,64712,64708,64704,64700,64696,64692,64688,64684,64680,64676,64672,64667,64663,64659,64655,64651,64647,64643,64639,64635,64630,64626,64622,64618,64614,64609,64605,64601,64597,64593,64588,64584,64580,64575,64571,64567,64563,64558,64554,64550,64545,64541,64536,64532,64528,64523,64519,64514,64510,64506,64501,64497,64492,64488,64483,64479,64474,64470,64465,64461,64456,64452,64447,64443,64438,64433,64429,64424,64420,64415,64410,64406,64401,64396,64392,64387,64382,64378,64373,64368,64363,64359,64354,64349,64344,64340,64335,64330,64325,64320,64316,64311,64306,64301,64296,64291,64287,64282,64277,64272,64267,64262,64257,64252,64247,64242,64237,64232,64227,64222,64217,64212,64207,64202,64197,64192,64187,64182,64177,64172,64167,64161,64156,64151,64146,64141,64136,64131,64125,64120,64115,64110,64105,64099,64094,64089,64084,64078,64073,64068,64062,64057,64052,64047,64041,64036,64031,64025,64020,64014,64009,64004,63998,63993,63987,63982,63976,63971,63966,63960,63955,63949,63944,63938,63933,63927,63922,63916,63910,63905,63899,63894,63888,63882,63877,63871,63866,63860,63854,63849,63843,63837,63832,63826,63820,63814,63809,63803,63797,63792,63786,63780,63774,63768,63763,63757,63751,63745,63739,63733,63728,63722,63716,63710,63704,63698,63692,63686,63680,63674,63668,63663,63657,63651,63645,63639,63633,63627,63621,63614,63608,63602,63596,63590,63584,63578,63572,63566,63560,63554,63547,63541,63535,63529,63523,63517,63510,63504,63498,63492,63486,63479,63473,63467,63461,63454,63448,63442,63435,63429,63423,63416,63410,63404,63397,63391,63385,63378,63372,63365,63359,63353,63346,63340,63333,63327,63320,63314,63307,63301,63294,63288,63281,63275,63268,63262,63255,63248,63242,63235,63229,63222,63215,63209,63202,63195,63189,63182,63175,63169,63162,63155,63149,63142,63135,63128,63122,63115,63108,63101,63095,63088,63081,63074,63067,63060,63054,63047,63040,63033,63026,63019,63012,63005,62998,62992,62985,62978,62971,62964,62957,62950,62943,62936,62929,62922,62915,62908,62901,62894,62886,62879,62872,62865,62858,62851,62844,62837,62830,62822,62815,62808,62801,62794,62787,62779,62772,62765,62758,62750,62743,62736,62729,62721,62714,62707,62699,62692,62685,62677,62670,62663,62655,62648,62641,62633,62626,62618,62611,62604,62596,62589,62581,62574,62566,62559,62551,62544,62536,62529,62521,62514,62506,62499,62491,62483,62476,62468,62461,62453,62445,62438,62430,62423,62415,62407,62400,62392,62384,62376,62369,62361,62353,62346,62338,62330,62322,62314,62307,62299,62291,62283,62275,62268,62260,62252,62244,62236,62228,62220,62212,62205,62197,62189,62181,62173,62165,62157,62149,62141,62133,62125,62117,62109,62101,62093,62085,62077,62069,62061,62053,62045,62036,62028,62020,62012,62004,61996,61988,61979,61971,61963,61955,61947,61939,61930,61922,61914,61906,61897,61889,61881,61873,61864,61856,61848,61839,61831,61823,61814,61806,61798,61789,61781,61772,61764,61756,61747,61739,61730,61722,61713,61705,61697,61688,61680,61671,61663,61654,61646,61637,61628,61620,61611,61603,61594,61586,61577,61568,61560,61551,61543,61534,61525,61517,61508,61499,61491,61482,61473,61464,61456,61447,61438,61429,61421,61412,61403,61394,61386,61377,61368,61359,61350,61341,61333,61324,61315,61306,61297,61288,61279,61270,61261,61253,61244,61235,61226,61217,61208,61199,61190,61181,61172,61163,61154,61145,61136,61127,61117,61108,61099,61090,61081,61072,61063,61054,61045,61035,61026,61017,61008,60999,60990,60980,60971,60962,60953,60943,60934,60925,60916,60906,60897,60888,60879,60869,60860,60851,60841,60832,60823,60813,60804,60794,60785,60776,60766,60757,60747,60738,60728,60719,60710,60700,60691,60681,60672,60662,60653,60643,60634,60624,60614,60605,60595,60586,60576,60567,60557,60547,60538,60528,60518,60509,60499,60490,60480,60470,60460,60451,60441,60431,60422,60412,60402,60392,60383,60373,60363,60353,60343,60334,60324,60314,60304,60294,60284,60275,60265,60255,60245,60235,60225,60215,60205,60195,60185,60175,60166,60156,60146,60136,60126,60116,60106,60096,60086,60075,60065,60055,60045,60035,60025,60015,60005,59995,59985,59975,59964,59954,59944,59934,59924,59914,59903,59893,59883,59873,59863,59852,59842,59832,59822,59811,59801,59791,59781,59770,59760,59750,59739,59729,59719,59708,59698,59687,59677,59667,59656,59646,59635,59625,59615,59604,59594,59583,59573,59562,59552,59541,59531,59520,59510,59499,59489,59478,59468,59457,59446,59436,59425,59415,59404,59393,59383,59372,59362,59351,59340,59330,59319,59308,59297,59287,59276,59265,59255,59244,59233,59222,59212,59201,59190,59179,59168,59158,59147,59136,59125,59114,59103,59093,59082,59071,59060,59049,59038,59027,59016,59005,58994,58983,58972,58962,58951,58940,58929,58918,58907,58896,58885,58873,58862,58851,58840,58829,58818,58807,58796,58785,58774,58763,58751,58740,58729,58718,58707,58696,58685,58673,58662,58651,58640,58628,58617,58606,58595,58583,58572,58561,58550,58538,58527,58516,58504,58493,58482,58470,58459,58448,58436,58425,58414,58402,58391,58379,58368,58356,58345,58334,58322,58311,58299,58288,58276,58265,58253,58242,58230,58219,58207,58195,58184,58172,58161,58149,58138,58126,58114,58103,58091,58079,58068,58056,58045,58033,58021,58009,57998,57986,57974,57963,57951,57939,57927,57916,57904,57892,57880,57869,57857,57845,57833,57821,57809,57798,57786,57774,57762,57750,57738,57726,57714,57703,57691,57679,57667,57655,57643,57631,57619,57607,57595,57583,57571,57559,57547,57535,57523,57511,57499,57487,57475,57463,57450,57438,57426,57414,57402,57390,57378,57366,57353,57341,57329,57317,57305,57293,57280,57268,57256,57244,57231,57219,57207,57195,57182,57170,57158,57145,57133,57121,57109,57096,57084,57072,57059,57047,57034,57022,57010,56997,56985,56972,56960,56948,56935,56923,56910,56898,56885,56873,56860,56848,56835,56823,56810,56798,56785,56773,56760,56747,56735,56722,56710,56697,56684,56672,56659,56647,56634,56621,56609,56596,56583,56571,56558,56545,56533,56520,56507,56494,56482,56469,56456,56443,56431,56418,56405,56392,56379,56367,56354,56341,56328,56315,56302,56289,56277,56264,56251,56238,56225,56212,56199,56186,56173,56160,56147,56134,56121,56108,56095,56082,56069,56056,56043,56030,56017,56004,55991,55978,55965,55952,55939,55926,55913,55900,55887,55873,55860,55847,55834,55821,55808,55794,55781,55768,55755,55742,55728,55715,55702,55689,55675,55662,55649,55636,55622,55609,55596,55582,55569,55556,55542,55529,55516,55502,55489,55476,55462,55449,55435,55422,55409,55395,55382,55368,55355,55341,55328,55314,55301,55288,55274,55260,55247,55233,55220,55206,55193,55179,55166,55152,55139,55125,55111,55098,55084,55071,55057,55043,55030,55016,55002,54989,54975,54961,54948,54934,54920,54906,54893,54879,54865,54852,54838,54824,54810,54796,54783,54769,54755,54741,54727,54714,54700,54686,54672,54658,54644,54630,54617,54603,54589,54575,54561,54547,54533,54519,54505,54491,54477,54463,54449,54435,54421,54407,54393,54379,54365,54351,54337,54323,54309,54295,54281,54267,54253,54239,54224,54210,54196,54182,54168,54154,54140,54125,54111,54097,54083,54069,54054,54040,54026,54012,53998,53983,53969,53955,53941,53926,53912,53898,53883,53869,53855,53840,53826,53812,53797,53783,53769,53754,53740,53726,53711,53697,53682,53668,53653,53639,53625,53610,53596,53581,53567,53552,53538,53523,53509,53494,53480,53465,53451,53436,53422,53407,53392,53378,53363,53349,53334,53319,53305,53290,53276,53261,53246,53232,53217,53202,53188,53173,53158,53144,53129,53114,53099,53085,53070,53055,53040,53026,53011,52996,52981,52967,52952,52937,52922,52907,52892,52878,52863,52848,52833,52818,52803,52788,52773,52759,52744,52729,52714,52699,52684,52669,52654,52639,52624,52609,52594,52579,52564,52549,52534,52519,52504,52489,52474,52459,52444,52429,52414,52398,52383,52368,52353,52338,52323,52308,52293,52277,52262,52247,52232,52217,52202,52186,52171,52156,52141,52126,52110,52095,52080,52065,52049,52034,52019,52003,51988,51973,51957,51942,51927,51911,51896,51881,51865,51850,51835,51819,51804,51789,51773,51758,51742,51727,51711,51696,51681,51665,51650,51634,51619,51603,51588,51572,51557,51541,51526,51510,51495,51479,51463,51448,51432,51417,51401,51386,51370,51354,51339,51323,51307,51292,51276,51260,51245,51229,51213,51198,51182,51166,51151,51135,51119,51104,51088,51072,51056,51041,51025,51009,50993,50977,50962,50946,50930,50914,50898,50882,50867,50851,50835,50819,50803,50787,50771,50756,50740,50724,50708,50692,50676,50660,50644,50628,50612,50596,50580,50564,50548,50532,50516,50500,50484,50468,50452,50436,50420,50404,50388,50372,50356,50340,50324,50307,50291,50275,50259,50243,50227,50211,50195,50178,50162,50146,50130,50114,50097,50081,50065,50049,50033,50016,50000,49984,49968,49951,49935,49919,49902,49886,49870,49854,49837,49821,49805,49788,49772,49756,49739,49723,49706,49690,49674,49657,49641,49624,49608,49592,49575,49559,49542,49526,49509,49493,49476,49460,49443,49427,49410,49394,49377,49361,49344,49328,49311,49295,49278,49262,49245,49228,49212,49195,49179,49162,49145,49129,49112,49095,49079,49062,49045,49029,49012,48995,48979,48962,48945,48929,48912,48895,48878,48862,48845,48828,48811,48795,48778,48761,48744,48727,48711,48694,48677,48660,48643,48626,48610,48593,48576,48559,48542,48525,48508,48491,48474,48458,48441,48424,48407,48390,48373,48356,48339,48322,48305,48288,48271,48254,48237,48220,48203,48186,48169,48152,48135,48118,48101,48084,48067,48049,48032,48015,47998,47981,47964,47947,47930,47912,47895,47878,47861,47844,47827,47809,47792,47775,47758,47741,47723,47706,47689,47672,47654,47637,47620,47603,47585,47568,47551,47534,47516,47499,47482,47464,47447,47430,47412,47395,47378,47360,47343,47325,47308,47291,47273,47256,47238,47221,47204,47186,47169,47151,47134,47116,47099,47081,47064,47046,47029,47011,46994,46976,46959,46941,46924,46906,46889,46871,46853,46836,46818,46801,46783,46765,46748,46730,46713,46695,46677,46660,46642,46624,46607,46589,46571,46554,46536,46518,46501,46483,46465,46447,46430,46412,46394,46376,46359,46341,46323,46305,46288,46270,46252,46234,46216,46199,46181,46163,46145,46127,46109,46091,46074,46056,46038,46020,46002,45984,45966,45948,45930,45912,45895,45877,45859,45841,45823,45805,45787,45769,45751,45733,45715,45697,45679,45661,45643,45625,45607,45589,45571,45552,45534,45516,45498,45480,45462,45444,45426,45408,45390,45371,45353,45335,45317,45299,45281,45262,45244,45226,45208,45190,45172,45153,45135,45117,45099,45080,45062,45044,45026,45007,44989,44971,44953,44934,44916,44898,44879,44861,44843,44824,44806,44788,44769,44751,44733,44714,44696,44677,44659,44641,44622,44604,44585,44567,44549,44530,44512,44493,44475,44456,44438,44419,44401,44382,44364,44345,44327,44308,44290,44271,44253,44234,44216,44197,44179,44160,44141,44123,44104,44086,44067,44049,44030,44011,43993,43974,43955,43937,43918,43899,43881,43862,43843,43825,43806,43787,43769,43750,43731,43713,43694,43675,43656,43638,43619,43600,43581,43562,43544,43525,43506,43487,43469,43450,43431,43412,43393,43374,43356,43337,43318,43299,43280,43261,43242,43223,43205,43186,43167,43148,43129,43110,43091,43072,43053,43034,43015,42996,42977,42958,42939,42920,42901,42882,42863,42844,42825,42806,42787,42768,42749,42730,42711,42692,42673,42654,42635,42616,42597,42578,42558,42539,42520,42501,42482,42463,42444,42424,42405,42386,42367,42348,42329,42309,42290,42271,42252,42233,42213,42194,42175,42156,42136,42117,42098,42079,42059,42040,42021,42002,41982,41963,41944,41924,41905,41886,41866,41847,41828,41808,41789,41770,41750,41731,41711,41692,41673,41653,41634,41614,41595,41576,41556,41537,41517,41498,41478,41459,41439,41420,41401,41381,41362,41342,41323,41303,41283,41264,41244,41225,41205,41186,41166,41147,41127,41108,41088,41068,41049,41029,41010,40990,40970,40951,40931,40912,40892,40872,40853,40833,40813,40794,40774,40754,40735,40715,40695,40675,40656,40636,40616,40597,40577,40557,40537,40518,40498,40478,40458,40439,40419,40399,40379,40359,40340,40320,40300,40280,40260,40241,40221,40201,40181,40161,40141,40121,40102,40082,40062,40042,40022,40002,39982,39962,39942,39922,39902,39882,39863,39843,39823,39803,39783,39763,39743,39723,39703,39683,39663,39643,39623,39603,39583,39563,39543,39523,39503,39482,39462,39442,39422,39402,39382,39362,39342,39322,39302,39282,39261,39241,39221,39201,39181,39161,39141,39120,39100,39080,39060,39040,39020,38999,38979,38959,38939,38919,38898,38878,38858,38838,38817,38797,38777,38757,38736,38716,38696,38675,38655,38635,38615,38594,38574,38554,38533,38513,38493,38472,38452,38432,38411,38391,38370,38350,38330,38309,38289,38269,38248,38228,38207,38187,38166,38146,38126,38105,38085,38064,38044,38023,38003,37982,37962,37941,37921,37900,37880,37859,37839,37818,37798,37777,37757,37736,37716,37695,37674,37654,37633,37613,37592,37572,37551,37530,37510,37489,37469,37448,37427,37407,37386,37365,37345,37324,37303,37283,37262,37241,37221,37200,37179,37159,37138,37117,37097,37076,37055,37034,37014,36993,36972,36951,36931,36910,36889,36868,36848,36827,36806,36785,36764,36744,36723,36702,36681,36660,36639,36619,36598,36577,36556,36535,36514,36493,36473,36452,36431,36410,36389,36368,36347,36326,36305,36284,36263,36243,36222,36201,36180,36159,36138,36117,36096,36075,36054,36033,36012,35991,35970,35949,35928,35907,35886,35865,35844,35823,35802,35781,35759,35738,35717,35696,35675,35654,35633,35612,35591,35570,35549,35527,35506,35485,35464,35443,35422,35401,35380,35358,35337,35316,35295,35274,35252,35231,35210,35189,35168,35146,35125,35104,35083,35062,35040,35019,34998,34977,34955,34934,34913,34892,34870,34849,34828,34806,34785,34764,34743,34721,34700,34679,34657,34636,34615,34593,34572,34551,34529,34508,34486,34465,34444,34422,34401,34380,34358,34337,34315,34294,34272,34251,34230,34208,34187,34165,34144,34122,34101,34079,34058,34037,34015,33994,33972,33951,33929,33908,33886,33865,33843,33821,33800,33778,33757,33735,33714,33692,33671,33649,33628,33606,33584,33563,33541,33520,33498,33476,33455,33433,33412,33390,33368,33347,33325,33303,33282,33260,33238,33217,33195,33173,33152,33130,33108,33087,33065,33043,33022,33000,32978,32956,32935,32913,32891,32870,32848,32826,32804,32783,32761,32739,32717,32695,32674,32652,32630,32608,32586,32565,32543,32521,32499,32477,32456,32434,32412,32390,32368,32346,32324,32303,32281,32259,32237,32215,32193,32171,32149,32127,32106,32084,32062,32040,32018,31996,31974,31952,31930,31908,31886,31864,31842,31820,31798,31776,31754,31732,31710,31688,31666,31644,31622,31600,31578,31556,31534,31512,31490,31468,31446,31424,31402,31380,31358,31336,31314,31292,31270,31248,31225,31203,31181,31159,31137,31115,31093,31071,31049,31026,31004,30982,30960,30938,30916,30893,30871,30849,30827,30805,30783,30760,30738,30716,30694,30672,30649,30627,30605,30583,30560,30538,30516,30494,30472,30449,30427,30405,30382,30360,30338,30316,30293,30271,30249,30226,30204,30182,30160,30137,30115,30093,30070,30048,30026,30003,29981,29959,29936,29914,29891,29869,29847,29824,29802,29780,29757,29735,29712,29690,29668,29645,29623,29600,29578,29555,29533,29511,29488,29466,29443,29421,29398,29376,29353,29331,29308,29286,29264,29241,29219,29196,29174,29151,29129,29106,29083,29061,29038,29016,28993,28971,28948,28926,28903,28881,28858,28835,28813,28790,28768,28745,28723,28700,28677,28655,28632,28610,28587,28564,28542,28519,28496,28474,28451,28429,28406,28383,28361,28338,28315,28293,28270,28247,28225,28202,28179,28156,28134,28111,28088,28066,28043,28020,27998,27975,27952,27929,27907,27884,27861,27838,27816,27793,27770,27747,27725,27702,27679,27656,27633,27611,27588,27565,27542,27519,27497,27474,27451,27428,27405,27382,27360,27337,27314,27291,27268,27245,27223,27200,27177,27154,27131,27108,27085,27062,27040,27017,26994,26971,26948,26925,26902,26879,26856,26833,26810,26787,26765,26742,26719,26696,26673,26650,26627,26604,26581,26558,26535,26512,26489,26466,26443,26420,26397,26374,26351,26328,26305,26282,26259,26236,26213,26190,26167,26144,26121,26098,26075,26051,26028,26005,25982,25959,25936,25913,25890,25867,25844,25821,25798,25774,25751,25728,25705,25682,25659,25636,25613,25589,25566,25543,25520,25497,25474,25451,25427,25404,25381,25358,25335,25312,25288,25265,25242,25219,25196,25172,25149,25126,25103,25080,25056,25033,25010,24987,24963,24940,24917,24894,24870,24847,24824,24801,24777,24754,24731,24708,24684,24661,24638,24614,24591,24568,24545,24521,24498,24475,24451,24428,24405,24381,24358,24335,24311,24288,24265,24241,24218,24195,24171,24148,24124,24101,24078,24054,24031,24008,23984,23961,23937,23914,23891,23867,23844,23820,23797,23774,23750,23727,23703,23680,23656,23633,23610,23586,23563,23539,23516,23492,23469,23445,23422,23398,23375,23351,23328,23304,23281,23257,23234,23210,23187,23163,23140,23116,23093,23069,23046,23022,22999,22975,22952,22928,22905,22881,22858,22834,22810,22787,22763,22740,22716,22693,22669,22645,22622,22598,22575,22551,22527,22504,22480,22457,22433,22409,22386,22362,22339,22315,22291,22268,22244,22220,22197,22173,22149,22126,22102,22078,22055,22031,22007,21984,21960,21936,21913,21889,21865,21842,21818,21794,21771,21747,21723,21699,21676,21652,21628,21604,21581,21557,21533,21510,21486,21462,21438,21415,21391,21367,21343,21320,21296,21272,21248,21224,21201,21177,21153,21129,21106,21082,21058,21034,21010,20987,20963,20939,20915,20891,20867,20844,20820,20796,20772,20748,20724,20701,20677,20653,20629,20605,20581,20557,20534,20510,20486,20462,20438,20414,20390,20366,20343,20319,20295,20271,20247,20223,20199,20175,20151,20127,20103,20080,20056,20032,20008,19984,19960,19936,19912,19888,19864,19840,19816,19792,19768,19744,19720,19696,19672,19648,19624,19600,19577,19553,19529,19505,19481,19457,19433,19409,19385,19361,19337,19313,19288,19264,19240,19216,19192,19168,19144,19120,19096,19072,19048,19024,19000,18976,18952,18928,18904,18880,18856,18832,18808,18783,18759,18735,18711,18687,18663,18639,18615,18591,18567,18543,18518,18494,18470,18446,18422,18398,18374,18350,18325,18301,18277,18253,18229,18205,18181,18156,18132,18108,18084,18060,18036,18012,17987,17963,17939,17915,17891,17867,17842,17818,17794,17770,17746,17721,17697,17673,17649,17625,17600,17576,17552,17528,17504,17479,17455,17431,17407,17382,17358,17334,17310,17285,17261,17237,17213,17188,17164,17140,17116,17091,17067,17043,17019,16994,16970,16946,16922,16897,16873,16849,16824,16800,16776,16751,16727,16703,16679,16654,16630,16606,16581,16557,16533,16508,16484,16460,16435,16411,16387,16362,16338,16314,16289,16265,16241,16216,16192,16168,16143,16119,16095,16070,16046,16021,15997,15973,15948,15924,15900,15875,15851,15826,15802,15778,15753,15729,15704,15680,15656,15631,15607,15582,15558,15534,15509,15485,15460,15436,15411,15387,15363,15338,15314,15289,15265,15240,15216,15192,15167,15143,15118,15094,15069,15045,15020,14996,14971,14947,14922,14898,14874,14849,14825,14800,14776,14751,14727,14702,14678,14653,14629,14604,14580,14555,14531,14506,14482,14457,14433,14408,14384,14359,14334,14310,14285,14261,14236,14212,14187,14163,14138,14114,14089,14065,14040,14016,13991,13966,13942,13917,13893,13868,13844,13819,13794,13770,13745,13721,13696,13672,13647,13622,13598,13573,13549,13524,13499,13475,13450,13426,13401,13376,13352,13327,13303,13278,13253,13229,13204,13180,13155,13130,13106,13081,13056,13032,13007,12983,12958,12933,12909,12884,12859,12835,12810,12785,12761,12736,12711,12687,12662,12638,12613,12588,12564,12539,12514,12490,12465,12440,12415,12391,12366,12341,12317,12292,12267,12243,12218,12193,12169,12144,12119,12095,12070,12045,12020,11996,11971,11946,11922,11897,11872,11847,11823,11798,11773,11749,11724,11699,11674,11650,11625,11600,11575,11551,11526,11501,11476,11452,11427,11402,11377,11353,11328,11303,11278,11254,11229,11204,11179,11155,11130,11105,11080,11056,11031,11006,10981,10956,10932,10907,10882,10857,10833,10808,10783,10758,10733,10709,10684,10659,10634,10609,10585,10560,10535,10510,10485,10461,10436,10411,10386,10361,10336,10312,10287,10262,10237,10212,10188,10163,10138,10113,10088,10063,10039,10014,9989,9964,9939,9914,9890,9865,9840,9815,9790,9765,9740,9716,9691,9666,9641,9616,9591,9566,9542,9517,9492,9467,9442,9417,9392,9367,9343,9318,9293,9268,9243,9218,9193,9168,9144,9119,9094,9069,9044,9019,8994,8969,8944,8919,8895,8870,8845,8820,8795,8770,8745,8720,8695,8670,8646,8621,8596,8571,8546,8521,8496,8471,8446,8421,8396,8371,8346,8322,8297,8272,8247,8222,8197,8172,8147,8122,8097,8072,8047,8022,7997,7972,7947,7923,7898,7873,7848,7823,7798,7773,7748,7723,7698,7673,7648,7623,7598,7573,7548,7523,7498,7473,7448,7423,7398,7373,7348,7323,7298,7273,7249,7224,7199,7174,7149,7124,7099,7074,7049,7024,6999,6974,6949,6924,6899,6874,6849,6824,6799,6774,6749,6724,6699,6674,6649,6624,6599,6574,6549,6524,6499,6474,6449,6424,6399,6374,6349,6324,6299,6274,6249,6224,6199,6173,6148,6123,6098,6073,6048,6023,5998,5973,5948,5923,5898,5873,5848,5823,5798,5773,5748,5723,5698,5673,5648,5623,5598,5573,5548,5523,5498,5473,5448,5422,5397,5372,5347,5322,5297,5272,5247,5222,5197,5172,5147,5122,5097,5072,5047,5022,4997,4972,4946,4921,4896,4871,4846,4821,4796,4771,4746,4721,4696,4671,4646,4621,4596,4570,4545,4520,4495,4470,4445,4420,4395,4370,4345,4320,4295,4270,4244,4219,4194,4169,4144,4119,4094,4069,4044,4019,3994,3969,3943,3918,3893,3868,3843,3818,3793,3768,3743,3718,3693,3667,3642,3617,3592,3567,3542,3517,3492,3467,3442,3417,3391,3366,3341,3316,3291,3266,3241,3216,3191,3165,3140,3115,3090,3065,3040,3015,2990,2965,2940,2914,2889,2864,2839,2814,2789,2764,2739,2714,2688,2663,2638,2613,2588,2563,2538,2513,2488,2462,2437,2412,2387,2362,2337,2312,2287,2261,2236,2211,2186,2161,2136,2111,2086,2061,2035,2010,1985,1960,1935,1910,1885,1860,1834,1809,1784,1759,1734,1709,1684,1659,1633,1608,1583,1558,1533,1508,1483,1458,1432,1407,1382,1357,1332,1307,1282,1257,1231,1206,1181,1156,1131,1106,1081,1056,1030,1005,980,955,930,905,880,854,829,804,779,754,729,704,679,653,628,603,578,553,528,503,478,452,427,402,377,352,327,302,276,251,226,201,176,151,126,101,75,50,25,0,0};

    unsigned index = ((x.n + 0x4002) >> 2) & 0x3FFF;
    if (0x1FFF < index) {
        index = 0x4000 - index;
    }
    if ((int)index < 0x1000) {
        return _fix32::from_bits(sin_tbl[index]);
    }
    return _fix32::from_bits(-sin_tbl[0x2000 - index]);
}
static int _fix32_floor(_fix32 x) {
    return static_cast<int>(static_cast<unsigned>(x.n) & 0xFFFF0000) / (1<<16);
}
static _fix32 _fix32_min(_fix32 a, _fix32 b) {
    return a > b ? b : a;
}
static _fix32 _fix32_max(_fix32 a, _fix32 b) {
    return a > b ? a : b;
}
static _fix32 _fix32_abs(_fix32 x) {
    return x >= 0 ? x : -x;
}

#define float _fix32

#else //CELESTE_P8_FIXEDP

#define float float

#endif //CELESTE_P8_FIXEDP

#ifdef __cplusplus
#define this xthis //this is a keyword in C++
#endif

//i cant be bothered to put all function declarations in an appropiate place so ill just toss them all here:
static void PRELUDE(void);
static void PRELUDE_initclouds(void);
static void PRELUDE_initparticles(void);
static void title_screen(void);
static void load_room(int x, int y);
static void next_room(void);
static void psfx(int num);
static void restart_room(void);

#define bool Celeste_P8_bool_t
#define false 0
#define true 1

static float clamp(float val, float a, float b);
static float appr(float val, float target, float amount);
static float sign(float v);
static bool maybe(void);
static bool solid_at(int x,int y,int w,int h);
static bool ice_at(int x,int y,int w,int h);
static bool tile_flag_at(int x,int y,int w,int h,int flag);
static int tile_at(int x,int y);
static bool spikes_at(float x,float y,int w,int h,float xspd,float yspd);

//exported /imported functions
static Celeste_P8_cb_func_t Celeste_P8_call = NULL;

//exported
void Celeste_P8_set_call_func(Celeste_P8_cb_func_t func) {
    Celeste_P8_call = func;
}
static void pico8_srand(unsigned seed);
void Celeste_P8_set_rndseed(unsigned seed) {
    pico8_srand(seed);
}

///////PICO-8 functions
static inline void P8music(int track, int fade, int mask) {
    Celeste_P8_call(CELESTE_P8_MUSIC, track, fade, mask);
}
static inline void P8spr(int sprite, int x, int y, int cols, int rows, bool flipx, bool flipy) {
    Celeste_P8_call(CELESTE_P8_SPR, sprite, x, y, cols, rows, flipx, flipy);
}
static inline bool P8btn(int b) {
    return Celeste_P8_call(CELESTE_P8_BTN, b);
}
static inline void P8sfx(int id) {
    Celeste_P8_call(CELESTE_P8_SFX, id);
}
static inline void P8pal(int a, int b) {
    Celeste_P8_call(CELESTE_P8_PAL, a, b);
}
static inline void P8pal_reset() {
    Celeste_P8_call(CELESTE_P8_PAL_RESET);
}
static inline void P8circfill(int x, int y, int r, int c) {
    Celeste_P8_call(CELESTE_P8_CIRCFILL, x,y,r,c);
}
static inline void P8rectfill(int x, int y, int x2, int y2, int c) {
    Celeste_P8_call(CELESTE_P8_RECTFILL, x,y,x2,y2,c);
}
static inline void P8print(const char* str, int x, int y, int c) {
    Celeste_P8_call(CELESTE_P8_PRINT, str,x,y,c);
}
static inline void P8line(int x, int y, int x2, int y2, int c) {
    Celeste_P8_call(CELESTE_P8_LINE, x,y,x2,y2,c);
}
static inline int P8mget(int x, int y) {
    return Celeste_P8_call(CELESTE_P8_MGET, x,y);
}
static inline bool P8fget(int t, int f) {
    return Celeste_P8_call(CELESTE_P8_FGET, t,f);
}
static inline void P8camera(int x, int y) {
    Celeste_P8_call(CELESTE_P8_CAMERA, x, y);
}
static inline void P8map(int mx, int my, int tx, int ty, int mw, int mh, int mask) {
    Celeste_P8_call(CELESTE_P8_MAP, mx, my, tx, ty, mw, mh, mask);
}
//these values dont matter as set_rndseed should be called before init, as long as they arent both zero
static unsigned rnd_seed_lo = 0, rnd_seed_hi = 1;

static int pico8_random(int max) //decomp'd pico-8
{
    if (!max)
    {
        return 0;
    }
    rnd_seed_hi = ((rnd_seed_hi << 16) | (rnd_seed_hi >> 16)) + rnd_seed_lo;
    rnd_seed_lo += rnd_seed_hi;
    return rnd_seed_hi % (unsigned)max;
};

static void pico8_srand(unsigned seed) //also decomp'd
{
    int i;

    if (seed == 0)
    {
        rnd_seed_hi = 0x60009755;
        seed = 0xdeadbeef;
    }
    else
    {
        rnd_seed_hi = seed ^ 0xbead29ba;
    }
    for (i = 0x20; i > 0; i--) {
        rnd_seed_hi = ((rnd_seed_hi << 16) | (rnd_seed_hi >> 16)) + seed;
        seed += rnd_seed_hi;
    }
    rnd_seed_lo = seed;
}

#ifndef CELESTE_P8_FIXEDP

#if SDL_MAJOR_VERSION >= 2 && (defined (__NGAGE__) || defined (NGAGE_DEBUG))
inline double P8max(double left, double right) { return (left > right) ? left : right; }
inline double P8min(double left, double right) { return (left < right) ? left : right; }
#define P8abs SDL_fabsf
#define P8flr SDL_floorf
#define fmodf SDL_fmodf
#define sinf  SDL_sinf
#else
#define P8max fmaxf
#define P8min fminf
#define P8abs fabsf
#define P8flr floorf
#endif

// https://github.com/lemon-sherbet/ccleste/issues/1
static float P8modulo(float a, float b)
{
    return fmodf(fmodf(a, b) + b, b);
}

static float P8rnd(float max)
{
    int n = pico8_random(max * (1<<16));
    return (float)n / (1<<16);
}

static float P8sin(float x)
{
    return -sinf(x*6.2831853071796f); //https://pico-8.fandom.com/wiki/Math
}

#else //CELESTE_P8_FIXEDP

#define P8modulo _fix32_mod
#define P8max    _fix32_max
#define P8min    _fix32_min
#define P8abs    _fix32_abs
#define P8flr    _fix32_floor

static _fix32 P8rnd(_fix32 max)
{
    return _fix32::from_bits(pico8_random(max.n));
}

#define P8sin _fix32_sin
#endif

#define P8cos(x) (-P8sin((x)+0.25f)) //cos(x) = sin(x+pi/2)

#ifdef CELESTE_P8_FIXEDP
//these need explicit casts to int
#define P8pal(_a,_b) P8pal(int(_a), int(_b))
#define P8spr(_s,_x,_y,_c,_r,_fx,_fy) P8spr(int(_s), int(_x), int(_y), (_c),(_r), (_fx),(_fy))
#define P8circfill(_x,_y,_r,_c) P8circfill(int(_x), int(_y), int(_r), (_c))
#define P8rectfill(_x0,_y0,_x1,_y1,_c) P8rectfill(int(_x0),int(_y0),int(_x1),int(_y1), int(_c))
#define P8print(_s,_x,_y,_c) P8print(_s,int(_x),int(_y),(_c))
#define P8line(_x0,_y0,_x1,_y1,_c) P8line(int(_x0),int(_y0),int(_x1),int(_y1),(_c))
#define P8camera(_x,_y) P8camera(int(_x),int(_y))
static inline bool ice_at(float x,float y,float w,float h) { return ice_at(int(x),int(y),int(w),int(h)); }
static inline bool solid_at(float x,float y,float w,float h) { return solid_at(int(x),int(y),int(w),int(h)); }
#endif

#define MAX_OBJECTS 30
#define FRUIT_COUNT 30

////////////////////////////////////////////////

// ~celeste~
// matt thorson + noel berry

// globals
//////////////

typedef struct {float x,y;} VEC;
typedef struct {int x,y;} VECI;

static VECI room                   = { .x = 0, .y = 0 };
//static int num_objects           = 0;
static int  freeze                 = 0;
static int  shake                  = 0;
static bool will_restart           = false;
static int  delay_restart          = 0;
static bool got_fruit[FRUIT_COUNT] = { false };
static bool has_dashed             = false;
static int  sfx_timer              = 0;
static bool has_key                = false;
static bool pause_player           = false;
static bool flash_bg               = false;
static int  music_timer            = 0;

//these are originally implicit globals defined in title_screen()
static bool  new_bg                = false;
static int   frames, seconds;
static short minutes; //this variable can overflow in normal gameplay (after +500 hours)
static int   deaths, max_djump;
static bool  start_game;
static int   start_game_flash;

enum
{
    k_left  = 0,
    k_right = 1,
    k_up    = 2,
    k_down  = 3,
    k_jump  = 4,
    k_dash  = 5
};

//with this X macro table thing we can define the properties that each object type has, in the original lua code these properties
//are inferred from the `types` table
#define OBJ_PROP_LIST() \
    /* TYPE        TILE   HAS INIT  HAS UPDATE  HAS DRAW    IF_NOT_FRUIT */ \
    X(PLAYER,       -1,     Y,        Y,          Y,            false) \
    X(PLAYER_SPAWN,  1,     Y,        Y,          Y,            false) \
    X(SPRING,       18,     Y,        Y,          N,            false) \
    X(BALLOON,      22,     Y,        Y,          Y,            false) \
    X(SMOKE,        -1,     Y,        Y,          N,            false) \
    X(PLATFORM,     -1,     Y,        Y,          Y,            false) \
    X(FALL_FLOOR,   23,     Y,        Y,          Y,            false) \
    X(FRUIT,        26,     Y,        Y,          N,             true) \
    X(FLY_FRUIT,    28,     Y,        Y,          Y,             true) \
    X(FAKE_WALL,    64,     N,        Y,          Y,             true) \
    X(KEY,           8,     N,        Y,          N,             true) \
    X(CHEST,        20,     Y,        Y,          N,             true) \
    X(LIFEUP,       -1,     Y,        Y,          Y,            false) \
    X(MESSAGE,      86,     N,        N,          Y,            false) \
    X(BIG_CHEST,    96,     Y,        N,          Y,            false) \
    X(ORB,          -1,     Y,        N,          Y,            false) \
    X(FLAG,        118,     Y,        N,          Y,            false) \
    X(ROOM_TITLE,   -1,     Y,        N,          Y,            false)

typedef enum
{
#if defined (__NGAGE__)
#define X(t,ARGS...) OBJ_##t,
#else
#define X(t,...) OBJ_##t,
#endif
    OBJ_PROP_LIST()
#undef X
    OBJTYPE_COUNT
} OBJTYPE;

// entry point //
/////////////////

static void PRELUDE()
{
    //top-level init code has been moved into functions that are called here
    PRELUDE_initclouds();
    PRELUDE_initparticles();
}

void Celeste_P8_init() //identifiers beginning with underscores are reserved in C
{
    if (!Celeste_P8_call)
    {
        fprintf(stderr, "Warning: Celeste_P8_call is NULL.. have you called Celeste_P8_set_call_func()?\n");
    }

    PRELUDE();

    title_screen();
}

static void title_screen()
{
    int i;
    for (i = 0; i <= 29; i++)
    {
        got_fruit[i] = false;
    }
    frames           = 0;
    deaths           = 0;
    max_djump        = 1;
    start_game       = false;
    start_game_flash = 0;

    P8music(40,0,7);
    load_room(7,3);
}

static void begin_game()
{
    frames      = 0;
    seconds     = 0;
    minutes     = 0;
    music_timer = 0;
    start_game  = false;

    P8music(0,0,7);
    load_room(0,0);
}

static int level_index()
{
    return room.x % 8 + room.y * 8;
}

static bool is_title()
{
    return level_index() == 31;
}

// effects //
/////////////

typedef struct
{
    float x,y,spd,w;
} CLOUD;

static CLOUD clouds[17];

//top level init code has been moved into a function
static void PRELUDE_initclouds()
{
    int i;
    for (i=0; i<=16; i++)
    {
        clouds[i] = (CLOUD){
            .x   = P8rnd(128),
            .y   = P8rnd(128),
            .spd = 1+P8rnd(4),
            .w   = 32+P8rnd(32),
        };
    }
}

typedef struct
{
    bool active;
    float x,y,s,spd,off,c,h,t;
    VEC spd2; //used by dead particles, moved from spd
} PARTICLE;

static PARTICLE particles[25];
static PARTICLE dead_particles[8];

//top level init code has been moved into a function
static void PRELUDE_initparticles()
{
    int i;
    for (i=0; i<=24; i++)
    {
        particles[i].x   = P8rnd(128);
        particles[i].y   = P8rnd(128);
        particles[i].s   = 0+P8flr(P8rnd(5)/4);
        particles[i].spd = 0.25f+P8rnd(5);
        particles[i].off = P8rnd(1);
        particles[i].c   = 6+P8flr(0.5+P8rnd(1));
    }
}

typedef struct
{
    int x,y,w,h;

} HITBOX;

typedef struct
{
    float x,y,size;
    bool  isLast;

} HAIR;

//OBJECT strucutre
typedef struct
{
    bool  active;
    short id; //unique identifier for each object, incremented per object

    //inherited
    OBJTYPE type;
    bool    collideable, solids;
    float   spr;
    bool    flip_x, flip_y;
    float   x, y;
    HITBOX  hitbox;
    VEC     spd;
    VEC     rem;

    //player
    bool  p_jump, p_dash;
    int   grace, jbuffer, djump, dash_time;
    short dash_effect_time; //can underflow in normal gameplay (after 18 minutes)
    VEC   dash_target;
    VEC   dash_accel;
    float spr_off;
    bool  was_on_ground;
    HAIR  hair[5];              //also player_spawn

    //player_spawn
    int state, delay;
    VEC target;

    //spring
    int hide_in, hide_for;

    //balloon
    int   timer;
    float offset, start;

    //fruit
    float off;

    //fly_fruit
    bool  fly;
    float step;
    int   sfx_delay;

    //lifeup
    int   duration;
    float flash;

    //platform
    float last, dir;

    //message
    const char* text;
    float       index;
    VECI        off2; //changed from off..

    //big chest
    PARTICLE particles[50];
    int      particle_count;

    //flag
    int  score;
    bool show;

} OBJ;

//OBJ function declarations fuckery
#define when_Y(x) static void x(OBJ* this);
#define when_N(x) enum { x = 0 }; //OBJTYPE_prop definition requires a constant value, and `static cost void* x = NULL` doesn't count
#define X(name,t,has_init,has_update,has_draw,if_not_fruit) \
    when_##has_init (name##_init)                           \
    when_##has_update (name##_update)                       \
    when_##has_draw (name##_draw)
OBJ_PROP_LIST()
#undef X

typedef void (*obj_callback_t)(OBJ*);

struct objprop
{
    int tile;
    obj_callback_t init;
    obj_callback_t update;
    obj_callback_t draw;
    const char* nam;
    bool if_not_fruit;
};

static const struct objprop OBJTYPE_prop[] =
{
#define X(name,t,has_init,has_update,has_draw,_if_not_fruit) \
    [OBJ_##name] = {                                         \
        .tile = t,                                           \
        .init = (obj_callback_t)name##_init,                 \
        .update = (obj_callback_t)name##_update,             \
        .draw = (obj_callback_t)name##_draw,                 \
        .nam = #name,                                        \
        .if_not_fruit = _if_not_fruit                        \
    },
    OBJ_PROP_LIST()
#undef X
    {0}
};

#define OBJ_PROP(o) OBJTYPE_prop[(o)->type]

static OBJ objects[MAX_OBJECTS] = {
    { .active = false }
};

static void create_hair(OBJ* obj);
static void set_hair_color(int c);
static void draw_hair(OBJ* obj, int facing);
static void unset_hair_color(void);
static void kill_player(OBJ* obj);
static void break_fall_floor(OBJ* obj);
static void draw_time(float x, float y);
static OBJ* init_object(OBJTYPE type, float x, float y);
static void destroy_object(OBJ* obj);
static void draw_object(OBJ* obj);

//OBJECT FUNCTIONS MOVED HERE

static bool OBJ_is_solid(OBJ* obj, float ox, float oy);
static bool OBJ_is_ice(OBJ* obj, float ox, float oy);
static OBJ* OBJ_collide(OBJ* obj, OBJTYPE type, float ox, float oy);
static bool OBJ_check(OBJ* obj, OBJTYPE type, float ox, float oy);
static void OBJ_move(OBJ* obj, float ox, float oy);
static void OBJ_move_x(OBJ* obj, float amount, float start);
static void OBJ_move_y(OBJ* obj, float amount);

static bool OBJ_is_solid(OBJ* obj, float ox, float oy)
{
    if (oy>0 && !OBJ_check(obj, OBJ_PLATFORM,ox,0) && OBJ_check(obj, OBJ_PLATFORM,ox,oy))
    {
        return true;
    }
    return solid_at(obj->x+obj->hitbox.x+ox,obj->y+obj->hitbox.y+oy,obj->hitbox.w,obj->hitbox.h)
        || OBJ_check(obj, OBJ_FALL_FLOOR,ox,oy)
        || OBJ_check(obj, OBJ_FAKE_WALL,ox,oy);
}

static bool OBJ_is_ice(OBJ* obj, float ox, float oy)
{
    return ice_at(obj->x+obj->hitbox.x+ox,obj->y+obj->hitbox.y+oy,obj->hitbox.w,obj->hitbox.h);
}

static OBJ* OBJ_collide(OBJ* obj, OBJTYPE type, float ox, float oy)
{
    int i;
    for (i=0; i < MAX_OBJECTS; i++)
    {
        OBJ* other=&objects[i];
        if (other->active && other->type == type && other != obj && other->collideable &&
            other->x+other->hitbox.x+other->hitbox.w > obj->x+obj->hitbox.x+ox &&
            other->y+other->hitbox.y+other->hitbox.h > obj->y+obj->hitbox.y+oy &&
            other->x+other->hitbox.x < obj->x+obj->hitbox.x+obj->hitbox.w+ox &&
            other->y+other->hitbox.y < obj->y+obj->hitbox.y+obj->hitbox.h+oy)
        {
            return other;
        }
    }
    return NULL;
}

static bool OBJ_check(OBJ* obj, OBJTYPE type, float ox, float oy)
{
    return OBJ_collide(obj, type,ox,oy) != NULL;
}

static void OBJ_move(OBJ* obj, float ox, float oy)
{
    float amount;
    // [x] get move amount
    obj->rem.x += ox;
    amount      = P8flr(obj->rem.x + 0.5);
    obj->rem.x -= amount;
    OBJ_move_x(obj, amount,0);

    // [y] get move amount
    obj->rem.y += oy;
    amount      = P8flr(obj->rem.y + 0.5);
    obj->rem.y -= amount;
    OBJ_move_y(obj, amount);
}

static void OBJ_move_x(OBJ* obj, float amount, float start)
{
    if (obj->solids)
    {
        float step = sign(amount);
        float i;
        for (i=start; i <= P8abs(amount); i+=1)
        {
            if (!OBJ_is_solid(obj, step,0))
            {
                obj->x += step;
            }
            else
            {
                obj->spd.x = 0;
                obj->rem.x = 0;
                break;
            }
        }
    }
    else
    {
        obj->x += amount;
    }
}

static void OBJ_move_y(OBJ* obj, float amount)
{
    if (obj->solids)
    {
        float step = sign(amount);
        int   i;
        for (i=0; i <= P8abs(amount); i++)
        {
            if (!OBJ_is_solid(obj,0,step))
            {
                obj->y += step;
            }
            else
            {
                obj->spd.y = 0;
                obj->rem.y = 0;
                break;
            }
        }
    }
    else
    {
        obj->y += amount;
    }
}


// player entity //
///////////////////

static void PLAYER_init(OBJ* this)
{
    this->p_jump           = false;
    this->p_dash           = false;
    this->grace            = 0;
    this->jbuffer          = 0;
    this->djump            = max_djump;
    this->dash_time        = 0;
    this->dash_effect_time = 0;
    this->dash_target      = (VEC){.x=0,.y=0};
    this->dash_accel       = (VEC){.x=0,.y=0};
    this->hitbox           = (HITBOX){.x=1,.y=3,.w=6,.h=5};
    this->spr_off          = 0;
    this->was_on_ground    = false;
    create_hair(this);
}

static OBJ player_dummy_copy; //see below
static void PLAYER_update(OBJ* this)
{
    bool on_ground;
    bool on_ice;
    bool dash;
    bool jump;

    int  input = P8btn(k_right) ? 1 : (P8btn(k_left) ? -1 : 0);

    /*LEMON: in order to kill the player in these lines, while maintaining object slots in the same order as they would be in pico-8,
     *       we need to remove the object there but that shifts back the objects array which will make it so the rest of the player_update()
     *       function modifies data from a newly loaded object; which is bad, so we simulate the pico-8 behaviour of reading from and writing to
     *       a table that is not referenced in the objects table by switching to a dummy copy of the player object */

    bool do_kill_player = false;

    if (pause_player)
    {
        return;
    }

    // spikes collide
    if (spikes_at(this->x+this->hitbox.x,this->y+this->hitbox.y,this->hitbox.w,this->hitbox.h,this->spd.x,this->spd.y))
    {
        do_kill_player = true;
    }

    // bottom death
    if (this->y>128)
    {
        do_kill_player = true;
    }
    if (do_kill_player)
    {
        //switch to dummy copy, need to copy before destroying the object
        player_dummy_copy = *this;
        kill_player(this);
        this = &player_dummy_copy;
    }

    on_ground = OBJ_is_solid(this, 0,1);
    on_ice    = OBJ_is_ice(this, 0,1);

    // smoke particles
    if (on_ground && !this->was_on_ground)
    {
        init_object(OBJ_SMOKE,this->x,this->y+4);
    }

    jump = P8btn(k_jump) && !this->p_jump;
    this->p_jump = P8btn(k_jump);
    if ((jump))
    {
        this->jbuffer=4;
    }
    else if (this->jbuffer>0)
    {
        this->jbuffer-=1;
    }

    dash = P8btn(k_dash) && !this->p_dash;
    this->p_dash = P8btn(k_dash);

    if (on_ground)
    {
        this->grace=6;
        if (this->djump<max_djump)
        {
            psfx(54);
            this->djump=max_djump;
        }
    }
    else if (this->grace > 0)
    {
        this->grace-=1;
    }

    this->dash_effect_time -=1;
    if (this->dash_time > 0)
    {
        init_object(OBJ_SMOKE, this->x,this->y);
        this->dash_time-=1;
        this->spd.x=appr(this->spd.x,this->dash_target.x,this->dash_accel.x);
        this->spd.y=appr(this->spd.y,this->dash_target.y,this->dash_accel.y);
    }
    else
    {
        // move
        int   maxrun = 1;
        float accel  = 0.6;
        float d_full;
        float d_half;
        float maxfall;
        float gravity;

        if (!on_ground)
        {
            accel=0.4;
        }
        else if (on_ice)
        {
            accel=0.05;
            if (input==(this->flip_x ? -1 : 1))
            {
                accel=0.05;
            }
        }

        if (P8abs(this->spd.x) > maxrun)
        {
            float deccel=0.15;
            this->spd.x=appr(this->spd.x,sign(this->spd.x)*maxrun,deccel);
        }
        else
        {
            this->spd.x=appr(this->spd.x,input*maxrun,accel);
        }

        //facing
        if (this->spd.x!=0)
        {
            this->flip_x=(this->spd.x<0);
        }

        // gravity
        maxfall=2;
        gravity=0.21;

        if (P8abs(this->spd.y) <= 0.15)
        {
            gravity*=0.5;
        }

        // wall slide
        if (input!=0 && OBJ_is_solid(this, input,0) && !OBJ_is_ice(this, input,0))
        {
            maxfall=0.4;
            if (P8rnd(10)<2)
            {
                init_object(OBJ_SMOKE,this->x+input*6,this->y);
            }
        }

        if (!on_ground)
        {
            this->spd.y=appr(this->spd.y,maxfall,gravity);
        }

        // jump
        if (this->jbuffer>0)
        {
            if (this->grace>0)
            {
                // normal jump
                psfx(1);
                this->jbuffer=0;
                this->grace=0;
                this->spd.y=-2;
                init_object(OBJ_SMOKE,this->x,this->y+4);
            }
            else
            {
                // wall jump
                int wall_dir=(OBJ_is_solid(this, -3,0) ? -1 : (OBJ_is_solid(this, 3,0) ? 1 : 0));
                if (wall_dir!=0)
                {
                    psfx(2);
                    this->jbuffer=0;
                    this->spd.y=-2;
                    this->spd.x=-wall_dir*(maxrun+1);
                    if (!OBJ_is_ice(this, wall_dir*3,0))
                    {
                        init_object(OBJ_SMOKE,this->x+wall_dir*6,this->y);
                    }
                }
            }
        }

        // dash
        d_full=5;
        d_half=d_full*0.70710678118;

        if (this->djump>0 && dash)
        {
            int v_input;
            init_object(OBJ_SMOKE,this->x,this->y);
            this->djump            -= 1;
            this->dash_time         = 4;
            has_dashed              = true;
            this->dash_effect_time  = 10;
            v_input=(P8btn(k_up) ? -1 : (P8btn(k_down) ? 1 : 0));
            if (input!=0)
            {
                if (v_input!=0)
                {
                    this->spd.x=input*d_half;
                    this->spd.y=v_input*d_half;
                }
                else
                {
                    this->spd.x=input*d_full;
                    this->spd.y=0;
                }
            }
            else if (v_input!=0)
            {
                this->spd.x=0;
                this->spd.y=v_input*d_full;
            }
            else
            {
                this->spd.x=(this->flip_x ? -1 : 1);
                this->spd.y=0;
            }

            psfx(3);
            freeze              = 2;
            shake               = 6;
            this->dash_target.x = 2*sign(this->spd.x);
            this->dash_target.y = 2*sign(this->spd.y);
            this->dash_accel.x  = 1.5;
            this->dash_accel.y  = 1.5;

            if (this->spd.y<0)
            {
                this->dash_target.y*=.75;
            }

            if (this->spd.y!=0)
            {
                this->dash_accel.x*=0.70710678118f;
            }

            if (this->spd.x!=0)
            {
                this->dash_accel.y*=0.70710678118f;
            }
        }
        else if (dash && this->djump<=0)
        {
            psfx(9);
            init_object(OBJ_SMOKE,this->x,this->y);
        }
    }

    // animation
    this->spr_off+=0.25;
    if (!on_ground)
    {
        if (OBJ_is_solid(this, input,0))
        {
            this->spr=5;
        }
        else
        {
            this->spr=3;
        }
    }
    else if (P8btn(k_down))
    {
        this->spr=6;
    }
    else if (P8btn(k_up))
    {
        this->spr=7;
    }
    else if ((this->spd.x==0) || (!P8btn(k_left) && !P8btn(k_right)))
    {
        this->spr=1;
    }
    else
    {
        this->spr=1+((int)this->spr_off)%4;
    }

    // next level
    if (this->y<-4 && level_index()<30)
    {
        next_room();
    }

    // was on the ground
    this->was_on_ground=on_ground;
}

static void PLAYER_draw(OBJ* this)
{
    // clamp in screen
    if (this->x<-1 || this->x>121)
    {
        this->x     = clamp(this->x,-1,121);
        this->spd.x = 0;
    }

    set_hair_color(this->djump);
    draw_hair(this,this->flip_x ? -1 : 1);
    P8spr(this->spr,this->x,this->y,1,1,this->flip_x,this->flip_y);
    unset_hair_color();
}

static void psfx(int num)
{
    if (sfx_timer<=0)
    {
        P8sfx(num);
    }
}

void create_hair(OBJ* obj)
{
    int i;
    /*obj->hair = {};*/
    for (i=0;i<=4;i++)
    {
        obj->hair[i] = (HAIR) {
            .x=obj->x,
            .y=obj->y,
            .size=P8max(1,P8min(2,3-i)),
            .isLast = i == 4
        };
    }
}

static void set_hair_color(int djump)
{
    P8pal(8,(djump==1 ? 8 : (djump==2 ?(7+P8flr(((int)(((float)frames)/3.0))%2)*4) : 12)));
}

static void draw_hair(OBJ* obj, int facing)
{
    float last_x=obj->x+4-facing*2;
    float last_y=obj->y+(P8btn(k_down) ? 4 : 3);
    HAIR* h;
    int i = 0;
    do
    {
        h = &obj->hair[i++];
        h->x+=(last_x-h->x)/1.5;
        h->y+=(last_y+0.5-h->y)/1.5;
        P8circfill(h->x,h->y,h->size,8);
        last_x=h->x;
        last_y=h->y;
    }
    while (!h->isLast);
}

static void unset_hair_color()
{
    P8pal(8,8);
}

//player_spawn
static void PLAYER_SPAWN_init(OBJ* this)
{
    P8sfx(4);
    this->spr      = 3;
    this->target.x = this->x;
    this->target.y = this->y;
    this->y        = 128;
    this->spd.y    = -4;
    this->state    = 0;
    this->delay    = 0;
    this->solids   = false;
    create_hair(this);
}
static void PLAYER_SPAWN_update(OBJ* this)
{
    // jumping up
    if (this->state==0)
    {
        if (this->y < this->target.y+16)
        {
            this->state=1;
            this->delay=3;
        }
        // falling
    }
    else if (this->state==1)
    {
        this->spd.y+=0.5;
        if (this->spd.y>0 && this->delay>0)
        {
            this->spd.y  = 0;
            this->delay -= 1;
        }
        if (this->spd.y>0 && this->y > this->target.y)
        {
            this->y     = this->target.y;
            this->spd.x = this->spd.y=0;
            this->state = 2;
            this->delay = 5;
            shake       = 5;
            init_object(OBJ_SMOKE,this->x,this->y+4);
            P8sfx(5);
        }
        // landing
    }
    else if (this->state==2)
    {
        this->delay -= 1;
        this->spr    = 6;
        if (this->delay<0)
        {
            float x = this->x, y = this->y;
            destroy_object(this);
            init_object(OBJ_PLAYER,x,y);
        }
    }
}

static void PLAYER_SPAWN_draw (OBJ* this)
{
    set_hair_color(max_djump);
    draw_hair(this,1);
    P8spr(this->spr,this->x,this->y,1,1,this->flip_x,this->flip_y);
    unset_hair_color();
}

//spring
static void SPRING_init(OBJ* this)
{
    this->hide_in  = 0;
    this->hide_for = 0;
}
static void SPRING_update(OBJ* this)
{
    if (this->hide_for>0)
    {
        this->hide_for-=1;
        if (this->hide_for<=0)
        {
            this->spr=18;
            this->delay=0;
        }
    }
    else if (this->spr==18)
    {
        OBJ* hit = OBJ_collide(this, OBJ_PLAYER,0,0);
        if (hit != NULL && hit->spd.y>=0)
        {
            OBJ* below;

            this->spr    = 19;
            hit->y       = this->y-4;
            hit->spd.x  *= 0.2;
            hit->spd.y   = -3;
            hit->djump   = max_djump;
            this->delay  = 10;
            init_object(OBJ_SMOKE,this->x,this->y);

            // breakable below us
            below=OBJ_collide(this, OBJ_FALL_FLOOR,0,1);
            if (below != NULL)
            {
                break_fall_floor(below);
            }

            psfx(8);
        }
    }
    else if (this->delay>0)
    {
        this->delay-=1;
        if (this->delay<=0)
        {
            this->spr=18;
        }
    }
    // begin hiding
    if (this->hide_in>0)
    {
        this->hide_in-=1;
        if (this->hide_in<=0)
        {
            this->hide_for=60;
            this->spr=0;
        }
    }
}

static void break_spring(OBJ* obj)
{
    obj->hide_in=15;
}

//balloon
static void BALLOON_init(OBJ* this)
{
    this->offset = P8rnd(1);
    this->start  = this->y;
    this->timer  = 0;
    this->hitbox = (HITBOX){.x=-1,.y=-1,.w=10,.h=10};
}

static void BALLOON_update(OBJ* this)
{
    if (this->spr==22)
    {
        OBJ* hit;
        this->offset+=0.01;
#ifdef CELESTE_P8_HACKED_BALLOONS
        //hacked balloons: constant y coord and hitbox. for TASes
        this->hitbox=(HITBOX){.x=-1,.y=-3,.w=10,.h=14};
#else
        this->y=this->start+P8sin(this->offset)*2;
#endif
        hit = OBJ_collide(this, OBJ_PLAYER, 0,0);
        if (hit != NULL && hit->djump<max_djump)
        {
            psfx(6);
            init_object(OBJ_SMOKE,this->x,this->y);
            hit->djump  = max_djump;
            this->spr   = 0;
            this->timer = 60;
        }
    }
    else if (this->timer>0)
    {
        this->timer-=1;
    }
    else
    {
        psfx(7);
        init_object(OBJ_SMOKE,this->x,this->y);
        this->spr=22;
    }
}

static void BALLOON_draw(OBJ* this)
{
    if (this->spr==22)
    {
        P8spr(13+(int)(this->offset*8)%3,this->x,this->y+6, 1,1,false,false);
        P8spr(this->spr,this->x,this->y,   1,1,false,false);
    }
}

//fall_floor
static void FALL_FLOOR_init(OBJ* this)
{
    this->state=0;
    //this->solid=true; //this is a typo.. not fixing in order to maintain original behaviour
}

static void FALL_FLOOR_update(OBJ* this)
{
    // idling
    if (this->state == 0)
    {
        if (OBJ_check(this, OBJ_PLAYER,0,-1) || OBJ_check(this, OBJ_PLAYER,-1,0) || OBJ_check(this, OBJ_PLAYER,1,0))
        {
            break_fall_floor(this);
        }
        // shaking
    }
    else if (this->state==1)
    {
        this->delay-=1;
        if (this->delay<=0)
        {
            this->state       = 2;
            this->delay       = 60; //how long it hides for
            this->collideable = false;
        }
        // invisible, waiting to reset
    }
    else if (this->state==2)
    {
        this->delay-=1;
        if (this->delay<=0 && !OBJ_check(this, OBJ_PLAYER,0,0))
        {
            psfx(7);
            this->state       = 0;
            this->collideable = true;
            init_object(OBJ_SMOKE,this->x,this->y);
        }
    }
}
static void FALL_FLOOR_draw(OBJ* this)
{
    if (this->state!=2)
    {
        if (this->state!=1) {
            P8spr(23,this->x,this->y, 1,1,false,false);
        }
        else
        {
            P8spr(23+(15-this->delay)/5,this->x,this->y, 1,1,false,false);
        }
    }
}

static void break_fall_floor(OBJ* obj)
{
    if (obj->state==0)
    {
        OBJ* hit;
        psfx(15);
        obj->state = 1;
        obj->delay = 15;        //how long until it falls
        init_object(OBJ_SMOKE,obj->x,obj->y);
        hit=OBJ_collide(obj, OBJ_SPRING,0,-1);
        if (hit != NULL)
        {
            break_spring(hit);
        }
    }
}

//smoke
static void SMOKE_init(OBJ* this)
{
    this->spr     = 29;
    this->spd.y   = -0.1;
    this->spd.x   = 0.3+P8rnd(0.2);
    this->x      += -1+P8rnd(2);
    this->y      += -1+P8rnd(2);
    this->flip_x  = maybe();
    this->flip_y  = maybe();
    this->solids  = false;
}

static void SMOKE_update(OBJ* this)
{
    this->spr+=0.2;
    if (this->spr>=32)
    {
        destroy_object(this);
    }
}

//fruit
//tile=26,
//if_not_fruit=true,
static void FRUIT_init(OBJ* this)
{
    this->start = this->y;
    this->off   = 0;
}

static void FRUIT_update(OBJ* this)
{
    OBJ* hit=OBJ_collide(this, OBJ_PLAYER,0,0);
    if (hit!=NULL)
    {
        hit->djump = max_djump;
        sfx_timer  = 20;
        P8sfx(13);
        got_fruit[level_index()] = true;
        init_object(OBJ_LIFEUP,this->x,this->y);
        destroy_object(this);
        return; //LEMON: added return to not modify dead object
    }
    this->off += 1;
    this->y    = this->start+P8sin(this->off/40)*2.5f;
}

//fly_fruit
//tile=28,
//if_not_fruit=true,
static void FLY_FRUIT_init(OBJ* this)
{
    this->start     = this->y;
    this->fly       = false;
    this->step      = 0.5;
    this->solids    = false;
    this->sfx_delay = 8;
}

static void FLY_FRUIT_update(OBJ* this)
{
    bool do_destroy_object = false; //LEMON: see PLAYER_update..
    OBJ* hit;
    //fly away
    if (this->fly)
    {
        if (this->sfx_delay>0)
        {
            this->sfx_delay-=1;
            if (this->sfx_delay<=0)
            {
                sfx_timer=20;
                P8sfx(14);
            }
        }
        this->spd.y=appr(this->spd.y,-3.5,0.25);
        if (this->y<-16)
        {
            do_destroy_object = true;
        }
        // wait
    }
    else
    {
        if (has_dashed)
        {
            this->fly=true;
        }
        this->step+=0.05;
        this->spd.y=P8sin(this->step)*0.5;
    }
    // collect
    hit=OBJ_collide(this, OBJ_PLAYER,0,0);
    if (hit!=NULL)
    {
        hit->djump=max_djump;
        sfx_timer=20;
        P8sfx(13);
        got_fruit[level_index()] = true;
        init_object(OBJ_LIFEUP,this->x,this->y);
        do_destroy_object = true;
    }
    if (do_destroy_object)
    {
        destroy_object(this);
    }
}

static void FLY_FRUIT_draw(OBJ* this)
{
    float off=0;
    if (!this->fly)
    {
        float dir=P8sin(this->step);
        if (dir<0)
        {
            off=1+P8max(0,sign(this->y-this->start));
        }
    }
    else
    {
        off=P8modulo(off+0.25, 3);
    }
    P8spr(45+off,this->x-6,this->y-2, 1,1,true,false);
    P8spr(this->spr,this->x,this->y,  1,1,false,false);
    P8spr(45+off,this->x+6,this->y-2, 1,1,false,false);
}

//lifeup
static void LIFEUP_init(OBJ* this)
{
    this->spd.y     = -0.25;
    this->duration  = 30;
    this->x        -= 2;
    this->y        -= 4;
    this->flash     = 0;
    this->solids    = false;
}

static void LIFEUP_update(OBJ* this)
{
    this->duration-=1;
    if (this->duration<= 0)
    {
        destroy_object(this);
    }
}

static void LIFEUP_draw(OBJ* this)
{
    this->flash+=0.5;

    P8print("1000",this->x-2,this->y,7+((int)this->flash)%2);
}

//fake_wall
//tile=64,
//if_not_fruit=true,
static void FAKE_WALL_update(OBJ* this)
{
    OBJ* hit;
    this->hitbox=(HITBOX){.x=-1,.y=-1,.w=18,.h=18};
    hit = OBJ_collide(this, OBJ_PLAYER,0,0);
    if (hit!=NULL && hit->dash_effect_time>0)
    {
        hit->spd.x     = -sign(hit->spd.x)*1.5;
        hit->spd.y     = -1.5;
        hit->dash_time = -1;
        sfx_timer      = 20;
        P8sfx(16);
        //destroy_object(this);
        init_object(OBJ_SMOKE,this->x,this->y);
        init_object(OBJ_SMOKE,this->x+8,this->y);
        init_object(OBJ_SMOKE,this->x,this->y+8);
        init_object(OBJ_SMOKE,this->x+8,this->y+8);
        init_object(OBJ_FRUIT,this->x+4,this->y+4);
        destroy_object(this); //LEMON: moved here. see PLAYER_update. also returning to avoid modifying removed object
        return;
    }
    this->hitbox=(HITBOX) {
        .x=0,
        .y=0,
        .w=16,
        .h=16
    };
}

static void FAKE_WALL_draw(OBJ* this)
{
    P8spr(64,this->x,this->y,     1,1,false,false);
    P8spr(65,this->x+8,this->y,   1,1,false,false);
    P8spr(80,this->x,this->y+8,   1,1,false,false);
    P8spr(81,this->x+8,this->y+8, 1,1,false,false);
}

//key
//tile=8,
//if_not_fruit=true,
static void KEY_update(OBJ* this)
{
    int is;
    int was=P8flr(this->spr);
    this->spr=9+(P8sin((float)frames/30.0)+0.5)*1;
    is=P8flr(this->spr);
    if (is==10 && is!=was)
    {
        this->flip_x=!this->flip_x;
    }
    if (OBJ_check(this, OBJ_PLAYER,0,0))
    {
        P8sfx(23);
        sfx_timer=10;
        destroy_object(this);
        has_key=true;
    }
}

//chest
//tile=20,
//if_not_fruit=true,
static void CHEST_init(OBJ* this)
{
    this->x-=4;
    this->start=this->x;
    this->timer=20;
}

static void CHEST_update(OBJ* this)
{
    if (has_key)
    {
        this->timer-=1;
        this->x=this->start-1+P8rnd(3);
        if (this->timer<=0)
        {
            sfx_timer=20;
            P8sfx(16);
            init_object(OBJ_FRUIT,this->x,this->y-4);
            destroy_object(this);
        }
    }
}

//platform
static void PLATFORM_init(OBJ* this)
{
    this->x        -= 4;
    this->solids    = false;
    this->hitbox.w  = 16;
    this->last      = this->x;
}

static void PLATFORM_update(OBJ* this)
{
    this->spd.x=this->dir*0.65;
    if (this->x<-16)
    {
        this->x=128;
    }
    else if (this->x>128)
    {
        this->x=-16;
    }
    if (!OBJ_check(this, OBJ_PLAYER,0,0))
    {
        OBJ* hit=OBJ_collide(this, OBJ_PLAYER,0,-1);
        if (hit!=NULL)
        {
            OBJ_move_x(hit, this->x-this->last,1);
        }
    }
    this->last=this->x;
}

static void PLATFORM_draw(OBJ* this)
{
    P8spr(11,this->x,this->y-1,   1,1,false,false);
    P8spr(12,this->x+8,this->y-1, 1,1,false,false);
}

//message
//tile=86,
//last=0,
static void MESSAGE_draw(OBJ* this)
{
    this->text="-- celeste mountain --#this memorial to those# perished on the climb";
    if (OBJ_check(this, OBJ_PLAYER,4,0))
    {
        int i;
        if (this->index<strlen(this->text))
        {
            this->index+=0.5;
            if (this->index>=this->last+1)
            {
                this->last+=1;
                P8sfx(35);
            }
        }
        this->off2.x = 8;
        this->off2.y = 96;
        for (i=0; i<this->index; i++)
        {
            if (this->text[i]!='#')
            {
                char charstr[2];
                P8rectfill(this->off2.x-2,this->off2.y-2,this->off2.x+7,this->off2.y+6, 7);
                charstr[0] = this->text[i], charstr[1] = '\0';
                P8print(charstr,this->off2.x,this->off2.y,0);
                this->off2.x+=5;
            }
            else
            {
                this->off2.x=8;
                this->off2.y+=7;
            }
        }
    }
    else
    {
        this->index=0;
        this->last=0;
    }
}

//big_chest
//tile=96,
static void BIG_CHEST_init(OBJ* this)
{
    this->state=0;
    this->hitbox.w=16;
}

static void BIG_CHEST_draw(OBJ* this)
{
    if (this->state==0)
    {
        OBJ* hit=OBJ_collide(this, OBJ_PLAYER,0,8);
        if (hit!=NULL && OBJ_is_solid(hit, 0,1))
        {
            P8music(-1,500,7);
            P8sfx(37);
            pause_player=true;
            hit->spd.x=0;
            hit->spd.y=0;
            this->state=1;
            init_object(OBJ_SMOKE,this->x,this->y);
            init_object(OBJ_SMOKE,this->x+8,this->y);
            this->timer=60;
            this->particle_count = 0;
        }
        P8spr(96,this->x,this->y,   1,1,false,false);
        P8spr(97,this->x+8,this->y,  1,1,false,false);
    }
    else if (this->state==1)
    {
        int i;
        this->timer-=1;
        shake=5;
        flash_bg=true;
        if (this->timer<=45 && this->particle_count<50)
        {
            this->particles[this->particle_count].x=1+P8rnd(14);
            this->particles[this->particle_count].y=0;
            this->particles[this->particle_count].spd=8+P8rnd(8);
            this->particles[this->particle_count].h=32+P8rnd(32);
            this->particle_count++;
        }
        if (this->timer<0)
        {
            this->state          = 2;
            this->particle_count = 0;
            flash_bg             = false;
            new_bg               = true;
            init_object(OBJ_ORB,this->x+4,this->y+4);
            pause_player         = false;
        }
        for (i = 0; i < this->particle_count; i++)
        {
            PARTICLE* p = &this->particles[i];
            p->y+=p->spd;
            P8line(this->x+p->x,this->y+8-p->y,this->x+p->x,P8min(this->y+8-p->y+p->h,this->y+8),7);
        }
    }
    P8spr(112,this->x,this->y+8,   1,1,false,false);
    P8spr(113,this->x+8,this->y+8, 1,1,false,false);
}

//orb
static void ORB_init(OBJ* this)
{
    this->spd.y          = -4;
    this->solids         = false;
    this->particle_count = 0;
}

static void ORB_draw(OBJ* this)
{
    bool  destroy_self = false;
    OBJ*  hit;
    float off;
    float i;

    this->spd.y=appr(this->spd.y,0,0.5);
    hit=OBJ_collide(this, OBJ_PLAYER,0,0);
    if (this->spd.y==0 && hit!=NULL)
    {
        music_timer  = 45;
        P8sfx(51);
        freeze       = 10;
        shake        = 10;
        destroy_self = true;    //LEMON: to avoid reading off dead object
        max_djump    = 2;
        hit->djump   = 2;
    }

    P8spr(102,this->x,this->y,  1,1,false,false);
    off=(float)frames/30.f;
    for (i=0; i <= 7; i+=1)
    {
        P8circfill(this->x+4+P8cos(off+i/8.f)*8,this->y+4+P8sin(off+i/8.f)*8,1,7);
    }
    if (destroy_self)
    {
        destroy_object(this);
    }
}

//flag
//tile=118,
static void FLAG_init(OBJ* this)
{
    int i;
    this->x     += 5;
    this->score  = 0;
    this->show   = false;
    for (i=0; i < FRUIT_COUNT; i++)
    {
        if (got_fruit[i])
        {
            this->score+=1;
        }
    }
}

static void FLAG_draw(OBJ* this)
{
    this->spr=118+P8modulo(((float)frames/5.f), 3);
    P8spr(this->spr,this->x,this->y, 1,1,false,false);
    if (this->show)
    {
        P8rectfill(32,2,96,31,0);
        P8spr(26,55,6, 1,1,false,false);
        {
            char str[16];
            snprintf(str, sizeof(str), "x%i", this->score);
            P8print(str,64,9,7);
        }
        draw_time(49,16);
        {
            char str[16];
            snprintf(str, sizeof(str), "deaths:%i", deaths);
            P8print(str,48,24,7);
        }
    }
    else if (OBJ_check(this, OBJ_PLAYER,0,0))
    {
        P8sfx(55);
        sfx_timer  = 30;
        this->show = true;
    }
}

//room_title
static void ROOM_TITLE_init(OBJ* this)
{
    this->delay=5;
}

static void ROOM_TITLE_draw(OBJ* this)
{
    this->delay-=1;
    if (this->delay<-30)
    {
        destroy_object(this);
    }
    else if (this->delay<0)
    {
        P8rectfill(24,58,104,70,0);
        //rect(26,64-10,102,64+10,7)
        //print("//-",31,64-2,13)
        if (room.x==3 && room.y==1)
        {
            P8print("old site",48,62,7);
        }
        else if (level_index()==30)
        {
            P8print("summit",52,62,7);
        }
        else
        {
            int level=(1+level_index())*100;
            {
                char str[16];
                snprintf(str, sizeof(str), "%i m", level);
                P8print(str,52+(level<1000 ? 2 : 0),62,7);
            }
        }
        //print("//-",86,64-2,13)

        draw_time(4,4);
    }
}

// object functions //
//////////////////////-

static OBJ* init_object(OBJTYPE type, float x, float y)
{
    static short next_id = 0;
    OBJ*         obj     = NULL;
    int          i;

    //if (type.if_not_fruit!=NULL && got_fruit[1+level_index()]) {
    if (OBJTYPE_prop[type].if_not_fruit && got_fruit[level_index()])
    {
        return NULL;
    }
    for (i = 0; i < MAX_OBJECTS; i++)
    {
        if (!objects[i].active) {
            obj = &objects[i];
            break;
        }
    }
    if (!obj)
    {
        //no more free space for objects, give up
        printf("exhausted object memory..\n");
        return NULL;
    }
    obj->active = true;
    obj->id     = next_id++;

    obj->type = type;
    obj->collideable = true;
    obj->solids      = true;

    obj->spr    = OBJTYPE_prop[type].tile;
    obj->flip_x = obj->flip_y = false;

    obj->x      = x;
    obj->y      = y;
    obj->hitbox = (HITBOX){ .x=0,.y=0,.w=8,.h=8 };

    obj->spd = (VEC){.x=0,.y=0};
    obj->rem = (VEC){.x=0,.y=0};

    //add(objects,obj)
    if (OBJ_PROP(obj).init!=NULL)
    {
        OBJ_PROP(obj).init(obj);
    }
    return obj;
}

static void destroy_object(OBJ* obj)
{
    //shift all slots to the right of this object to the left, necessary to simulate loading jank
    assert(obj >= objects && obj < objects + MAX_OBJECTS);
    for (; obj+1 < objects + MAX_OBJECTS; obj++)
    {
        *obj = *(obj+1);
    }
    objects[MAX_OBJECTS-1].active = false;
}

static void kill_player(OBJ* obj)
{
    int   dead_particles_count = 0;
    float dir;
    sfx_timer  = 12;
    P8sfx(0);
    deaths    += 1;
    shake      = 10;
    //destroy_object(obj);
    for (dir=0; dir <= 7; dir+=1)
    {
        float angle=(dir/8);
        dead_particles[dead_particles_count].active = true;
        dead_particles[dead_particles_count].x      = obj->x+4;
        dead_particles[dead_particles_count].y      = obj->y+4;
        dead_particles[dead_particles_count].t      = 10;
        dead_particles[dead_particles_count].spd2.x = P8sin(angle)*3;
        dead_particles[dead_particles_count].spd2.y = P8cos(angle)*3;
        dead_particles_count++;
        restart_room();
    }
    destroy_object(obj); //LEMON: moved here to avoid using ->x and ->y from dead object
}

// room functions //
////////////////////

static void restart_room()
{
    will_restart  = true;
    delay_restart = 15;
}

static void next_room()
{
    if (room.x==2 && room.y==1)
    {
        P8music(30,500,7);
    }
    else if (room.x==3 && room.y==1)
    {
        P8music(20,500,7);
    }
    else if (room.x==4 && room.y==2)
    {
        P8music(30,500,7);
    }
    else if (room.x==5 && room.y==3)
    {
        P8music(30,500,7);
    }

    if (room.x==7)
    {
        load_room(0,room.y+1);
    }
    else
    {
        load_room(room.x+1,room.y);
    }
}

static bool room_just_loaded = false; //for debugging loading jank

static void load_room(int x, int y)
{
    int i, tx, ty;
    has_dashed       = false;
    has_key          = false;
    room_just_loaded = true;

    //int oldcount = 0;
    //remove existing objects
    for (i = 0; i < MAX_OBJECTS; i++)
    {
        //oldcount += objects[i].active ? 1 : 0;
        objects[i].active = false;
    }
    //int newcount = 0;

    //current room
    room.x = x;
    room.y = y;

    // entities
    for (tx=0; tx <= 15; tx++)
    {
        for (ty=0; ty <= 15; ty++)
        {
            int tile = P8mget(room.x*16+tx,room.y*16+ty);
            if (tile==11)
            {
                init_object(OBJ_PLATFORM,tx*8,ty*8)->dir=-1;
                //newcount++;
            }
            else if (tile==12)
            {
                init_object(OBJ_PLATFORM,tx*8,ty*8)->dir=1;
                //newcount++;
            }
            else
            {
                int type;
                for (type = 0; type < OBJTYPE_COUNT; type++) //safe since types are ordered starting at 0
                {
                    if (tile == OBJTYPE_prop[type].tile)
                    {
                        init_object((OBJTYPE)type, tx*8, ty*8);
                        //newcount++;
                    }
                }
            }
        }
    }

    //printf("load_room(): deleted %i and loaded %i objects\n", oldcount, newcount);

    if (!is_title())
    {
        init_object(OBJ_ROOM_TITLE,0,0);
    }
}

// update function //
/////////////////////

void Celeste_P8_update()
{
    int i;

    frames=((frames+1)%30);
    if (frames==0 && level_index()<30)
    {
        seconds=((seconds+1)%60);
        if (seconds==0)
        {
            minutes+=1;
        }
    }

    if (music_timer>0)
    {
        music_timer-=1;
        if (music_timer<=0)
        {
            P8music(10,0,7);
        }
    }

    if (sfx_timer>0)
    {
        sfx_timer-=1;
    }

    // cancel if (freeze
    if (freeze>0)
    {
        freeze-=1;
        return;
    }

    // screenshake
    if (shake>0)
    {
        shake-=1;
        P8camera(0,0);
        if (shake>0)
        {
            P8camera(-2+P8rnd(5),-2+P8rnd(5));
        }
    }

    // restart (soon)
    if (will_restart && delay_restart>0)
    {
        delay_restart-=1;
        if (delay_restart<=0)
        {
            will_restart=false;
            load_room(room.x,room.y);
        }
    }

    //printf("BEGIN FRAME\n");
    room_just_loaded = false;
    // update each object
    for (i = 0; i < MAX_OBJECTS; i++)
    {
        OBJ*  obj = &objects[i];
        short this_id;

    redo_update_slot:
        if (!obj->active)
        {
            continue;
        }

        OBJ_move(obj, obj->spd.x,obj->spd.y);
        //printf("update #%i (%s)\n", i, OBJ_PROP(obj).nam);
        this_id = obj->id;
        if (OBJ_PROP(obj).update!=NULL)
        {
            OBJ_PROP(obj).update(obj);
        }

        if (room_just_loaded)
        {
            /*printf("update(): load room (player was: #%i)\n", i),*/
            room_just_loaded = false;
        }
        /*LEMON: necessary to correctly simulate loading jank: due to the way pico-8's foreach() works,
         *       when element #i is removed and replaced by another different object, the function iterates
         *       over this index again. thus for example, the player is in slot N before a new room is loaded,
         *       all objects are deleted and new objects are spawned, and the objects now in slots [N, last] are updated
         */
        if (this_id != obj->id)
        {
            goto redo_update_slot;
        }

    }
    //printf("END FRAME\n\n");

    // start game
    if (is_title())
    {
        if (!start_game && (P8btn(k_jump) || P8btn(k_dash)))
        {
            P8music(-1, 0, 0);
            start_game_flash=50;
            start_game=true;
            P8sfx(38);
        }
        if (start_game)
        {
            start_game_flash-=1;
            if (start_game_flash<=-30)
            {
                begin_game();
            }
        }
    }
}

// drawing functions //
//////////////////////-
void Celeste_P8_draw()
{
    int bg_col = 0;
    int i;
    int off;

    if (freeze>0)
    {
        return;
    }

    // reset all palette values
    P8pal_reset();

    // start game flash
    if (start_game)
    {
        int c=10;

        if (start_game_flash>10)
        {
            if (frames%10<5)
            {
                c=7;
            }
        }
        else if (start_game_flash>5)
        {
            c=2;
        }
        else if (start_game_flash>0)
        {
            c=1;
        }
        else
        {
            c=0;
        }
        if (c<10)
        {
            P8pal(6,c);
            P8pal(12,c);
            P8pal(13,c);
            P8pal(5,c);
            P8pal(1,c);
            P8pal(7,c);
        }
    }

    // clear screen
    if (flash_bg)
    {
        bg_col = frames/5;
    }
    else if (new_bg)
    {
        bg_col=2;
    }
    P8rectfill(0,0,128,128,bg_col);

    // clouds
    if (!is_title())
    {
        for (i = 0; i <= 16; i++)
        {
            CLOUD* c = &clouds[i];
            c->x += c->spd;
            P8rectfill(c->x,c->y,c->x+c->w,c->y+4+(1-c->w/64.0)*12,new_bg ? 14 : 1);
            if (c->x > 128)
            {
                c->x = -c->w;
                c->y = P8rnd(128-8);
            }
        }
    }

    // draw bg terrain
    P8map(room.x * 16,room.y * 16,0,0,16,16,4);

    // platforms/big chest
    for (i = 0; i < MAX_OBJECTS; i++)
    {
        OBJ* o = &objects[i];
        if (o->active && (o->type==OBJ_PLATFORM || o->type==OBJ_BIG_CHEST))
        {
            draw_object(o);
        }
    }

    // draw terrain
    off=is_title() ? -4 : 0;
    P8map(room.x*16,room.y * 16,off,0,16,16,2);

    // draw objects
    for (i = 0; i < MAX_OBJECTS; i++)
    {
        OBJ*  o = &objects[i];
        short this_id;
    redo_draw:;
        this_id = o->id;
        if (o->active && (o->type!=OBJ_PLATFORM && o->type!=OBJ_BIG_CHEST))
        {
            draw_object(o);
        }

        //LEMON: draw_object() could have deleted obj, and something could have been moved in its place, so check for that in order not to skip drawing an object
        if (this_id != o->id) goto redo_draw;
    }

    // draw fg terrain
    P8map(room.x * 16,room.y * 16,0,0,16,16,8);

    // particles
    for (i = 0; i <= 24; i++)
    {
        PARTICLE* p = &particles[i];
        p->x += p->spd;
        p->y += P8sin(p->off);
        p->off+= P8min(0.05,p->spd/32);
        P8rectfill(p->x,p->y,p->x+p->s,p->y+p->s,p->c);
        if (p->x>128+4)
        {
            p->x=-4;
            p->y=P8rnd(128);
        }
        p++;
    }

    // dead particles
    for (i = 0; i <= 7; i++)
    {
        PARTICLE* p = &dead_particles[i];
        if (p->active)
        {
            p->x += p->spd2.x;
            p->y += p->spd2.y;
            p->t -=1;
            if (p->t <= 0)
            {
                p->active = false;
            }
            P8rectfill(p->x-p->t/5,p->y-p->t/5,p->x+p->t/5,p->y+p->t/5,14+P8modulo(p->t,2));
        }

        p++;
    }

    // draw outside of the screen for screenshake
    P8rectfill(-5,-5,-1,133,0);
    P8rectfill(-5,-5,133,-1,0);
    P8rectfill(-5,128,133,133,0);
    P8rectfill(128,-5,133,133,0);

    // credits
    if (is_title())
    {
        P8print("v1.02",54,55,5);
#if defined (__NGAGE__) || defined (NGAGE_DEBUG)
        P8print("5+7",58,80,5);
#else
        P8print("x+c",58,80,5);
#endif
        P8print("maddy thorson",41,96,5);
        P8print("noel berry",46,102,5);
    }

    if (level_index()==30)
    {
        OBJ* p = NULL;
        for (i = 0; i < MAX_OBJECTS; i++)
        {
            if (objects[i].active && objects[i].type==OBJ_PLAYER)
            {
                p = &objects[i];
                break;
            }
        }
        if (p!=NULL)
        {
            float diff=P8min(24,40-P8abs(p->x+4-64));
            P8rectfill(0,0,diff,128,0);
            P8rectfill(128-diff,0,128,128,0);
        }
    }
}

static void draw_object(OBJ* obj)
{
    if (OBJ_PROP(obj).draw !=NULL)
    {
        OBJ_PROP(obj).draw(obj);
    }
    else if (obj->spr > 0)
    {
        P8spr(obj->spr,obj->x,obj->y,1,1,obj->flip_x,obj->flip_y);
    }
    //if (floorf(obj->spr) != obj->spr) printf("?%g %s\n", obj->spr, OBJ_PROP(obj).nam);
}

static void draw_time(float x, float y)
{
    int s=seconds;
    int m=minutes%60;
    int h=minutes/60;

    P8rectfill(x,y,x+32,y+6,0);
    {
        char str[27];
        snprintf(str, sizeof(str), "%.2i:%.2i:%.2i", h, m, s);
        P8print(str,x+1,y+1,7);
    }
}

// helper functions //
//////////////////////
static float clamp(float val, float a, float b)
{
    return P8max(a, P8min(b, val));
}

static float appr(float val, float target, float amount)
{
    return val > target
        ? P8max(val - amount, target)
        : P8min(val + amount, target);
}

static float sign(float v)
{
    return v > 0 ? 1 : (v < 0 ? -1 : 0);
}

static bool maybe()
{
    return P8rnd(1)<0.5;
}

static bool solid_at(int x,int y,int w,int h)
{
    return tile_flag_at(x,y,w,h,0);
}

static bool ice_at(int x,int y,int w,int h)
{
    return tile_flag_at(x,y,w,h,4);
}

static bool tile_flag_at(int x,int y,int w,int h,int flag)
{
    int i;
    for (i=(int)P8max(0,P8flr(x/8)); i <= P8min(15,(x+w-1)/8); i++)
    {
        int j;
        for (j=(int)P8max(0,P8flr(y/8)); j <= P8min(15,(y+h-1)/8); j++)
        {
            if (P8fget(tile_at(i,j),flag))
            {
                return true;
            }
        }
    }
    return false;
}

static int tile_at(int x,int y)
{
    return P8mget(room.x * 16 + x, room.y * 16 + y);
}

static bool spikes_at(float x,float y,int w,int h,float xspd,float yspd)
{
    int i;
    for (i=(int)P8max(0,P8flr(x/8)); i <= P8min(15,(x+w-1)/8); i++)
    {
        int j;
        for (j=(int)P8max(0,P8flr(y/8)); j <= P8min(15,(y+h-1)/8); j++)
        {
            int tile=tile_at(i,j);
            if (tile==17 && (P8modulo(y+h-1, 8)>=6 || y+h==j*8+8) && yspd>=0)
            {
                return true;
            }
            else if (tile==27 && P8modulo(y, 8)<=2 && yspd<=0)
            {
                return true;
            }
            else if (tile==43 && P8modulo(x, 8)<=2 && xspd<=0)
            {
                return true;
            }
            else if (tile==59 && (P8modulo(x+w-1, 8)>=6 || x+w==i*8+8) && xspd>=0)
            {
                return true;
            }
        }
    }
    return false;
}

//////////END/////////

void Celeste_P8__DEBUG(void)
{
    if (is_title())
    {
        start_game = true, start_game_flash=1;
    }
    else
    {
        next_room();
    }
}

//all of the global game variables; this holds the entire game state (exc. music/sounds playing)
#define LISTGVARS(V)                                                    \
    V(rnd_seed_lo) V(rnd_seed_hi)                                       \
        V(room) V(freeze) V(shake) V(will_restart) V(delay_restart) V(got_fruit) \
        V(has_dashed) V(sfx_timer) V(has_key) V(pause_player) V(flash_bg) V(music_timer) \
        V(new_bg) V(frames) V(seconds) V(minutes) V(deaths) V(max_djump) V(start_game) \
        V(start_game_flash) V(clouds) V(particles) V(dead_particles) V(objects)

size_t Celeste_P8_get_state_size(void)
{
#define V_SIZE(v) (sizeof v) +
    enum { //force comptime evaluation
        sz = LISTGVARS(V_SIZE) - 0
    };
    return sz;
#undef V_SIZE
}

void Celeste_P8_save_state(void* st_)
{
    char* st;
    assert(st_ != NULL);
    st = (char*)st_;
#define V_SAVE(v) memcpy(st, &v, sizeof v), st += sizeof v;
    LISTGVARS(V_SAVE)
#undef V_SAVE
}

void Celeste_P8_load_state(const void* st_)
{
    const char* st;
    assert(st_ != NULL);
    st = (const char*)st_;
#define V_LOAD(v) memcpy(&v, st, sizeof v), st += sizeof v;
    LISTGVARS(V_LOAD)
#undef V_LOAD
}

#undef LISTGVARS