Jazz Jackrabbit 2 Online

const bool MLLESetupSuccessful = MLLE::Setup(array<MLLEWeaponApply@> = {null, null, null, null, null, null, null, null, WeaponVMega::Backfire::Weapon()}); ///@MLLE-Generated
#include "MLLE-Include-1.7w.asc" ///@MLLE-Generated
#pragma require "HH24_level02-MLLE-Data-1.j2l" ///@MLLE-Generated
#pragma require "SSWorlds_SET 5.j2t" ///@MLLE-Generated
#pragma require "Castle1.j2t" ///@MLLE-Generated
#pragma require "CandionVPeaks.j2t" ///@MLLE-Generated
#pragma require "CrayonValleyXmas.j2t" ///@MLLE-Generated
#pragma require "HH24_level02.j2l" ///@MLLE-Generated
#include "WeaponVMega5.asc" ///@MLLE-Generated
#pragma require "WeaponVMega5.asc" ///@MLLE-Generated
#include "HH18Smoke_HH24.asc"
#pragma require "SExmas.j2a"
#include "HH24.asc"

array<bool> SavedTriggers(32, false);

///@Event 254=Delete This |-|Modifier |NOT |v

class Imitation : jjBEHAVIORINTERFACE {
    private uint8 eventID;
    private jjBEHAVIOR behavior;
    Imitation(uint8 realEventID, uint8 fakeEventID) {
        jjOBJ@ obj = jjObjectPresets[realEventID];
        eventID = obj.eventID;
        behavior = obj.behavior;
        obj.eventID = fakeEventID;
        obj.behavior = this;
    }
    void onBehave(jjOBJ@ obj) override {
        if (obj.state == STATE::DEACTIVATE)
            obj.eventID = eventID;
        obj.behave(behavior);
    }
}
 
class GiftBox : jjBEHAVIORINTERFACE {
    void destroy(jjOBJ@ obj) {
        jjSample(obj.xPos, obj.yPos, SOUND::COMMON_WOOD1);
        {
            int id = jjAddObject(OBJECT::EXPLOSION, obj.xPos, obj.yPos);
            if (id != 0) {
                jjOBJ@ other = jjObjects[id];
                other.determineCurAnim(ANIM::PICKUPS, 4);
            }
        }
        for (int i = jjRandom() & 7 | 8; i-- != 0;) {
            int id = jjAddObject(OBJECT::SHARD, obj.xPos, obj.yPos);
            if (id != 0) {
                jjOBJ@ other = jjObjects[id];
                other.determineCurAnim(ANIM::PICKUPS, 93 + (jjRandom() & 1));
            }
        }
        obj.yPos -= 8.f;
        for (int i = obj.var[1]; i-- != 0;) {
            int id = jjAddObject(obj.var[0], obj.xPos, obj.yPos);
            if (id != 0) {
                jjOBJ@ other = jjObjects[id];
                if (other.playerHandling == HANDLING::PICKUP) {
                    int angle = (jjRandom() & 255) + 128;
                    other.xSpeed = jjCos(angle) * 5.f;
                    other.ySpeed = jjSin(angle) * -3.f;
                } else if (other.playerHandling == HANDLING::SPECIAL) {
                    other.deactivates = false;
                }
            }
        }
        obj.clearPlatform();
        obj.delete();
    }
    void onBehave(jjOBJ@ obj) override {
        switch (obj.state) {
            case STATE::START:
                {
                    uint16 x = int(obj.xOrg) >>> 5;
                    uint16 y = int(obj.yOrg) >>> 5;
                    obj.var[0] = jjParameterGet(x, y, 0, 8);
                    obj.var[1] = jjParameterGet(x, y, 8, 4);
                    obj.curAnim += jjParameterGet(x, y, 12, 2);
                    obj.determineCurFrame();
                    obj.bulletHandling = HANDLING::DESTROYBULLET;
                    obj.scriptedCollisions = true;
                }
                break;
            case STATE::FALL:
                obj.var[2] = 1;
                break;
            case STATE::FREEZE:
            case STATE::SLEEP:
                if (obj.var[2] != 0) {
                    destroy(obj);
                    return;
                }
        }
        obj.behave(BEHAVIOR::MONITOR);
    }
    bool onObjectHit(jjOBJ@, jjOBJ@, jjPLAYER@, int) {
        return true;
    }
    bool onIsSolid(jjOBJ@) {
        return true;
    }
}

void onLevelLoad() { 
    Imitation(OBJECT::TACO, OBJECT::MILK);
    
    uint src = jjAnimSets[ANIM::CUSTOM[255]].load(0, "SExmas.j2a");
    uint dest = jjAnimSets[ANIM::PICKUPS];
    for (int i = 0; i < 95; i++) {
        const jjANIMATION@ anim = jjAnimations[src + i];
        if (anim.frameCount != 0)
            jjAnimations[dest + i] = anim;
    }
    
    jjAnimSets[ANIM::CUSTOM[0]].load(2, "SExmas.j2a");
	
	src = jjAnimSets[ANIM::CUSTOM[254]].load(0, "HH24.j2a");
    
    jjAnimations[dest + 11] = jjAnimations[src + 2]; // Burger -> Gingerbread Man
    jjAnimations[dest + 15] = jjAnimations[src + 4]; // Cheese -> Peppermint
    jjAnimations[dest + 32] = jjAnimations[src + 1]; // Fries -> Candy Cane (Red)
    jjAnimations[dest + 77] = jjAnimations[src]; // Pizza -> Candy Cane (Green)
    jjAnimations[dest + 88] = jjAnimations[src + 3]; // Taco -> Hot Cocoa
	
    jjAnimSets[ANIM::TUFTUR].load(1, "HH24.j2a");
    jjObjectPresets[OBJECT::TUFTURT].determineCurAnim(ANIM::TUFTUR, 0);
	
	auto layers = jjLayerOrderGet();
	jjLayerYOffset[7] = -6 * 32 + 10;
	for (uint additionalLayerID = 0; additionalLayerID < 4; ++additionalLayerID) {
		jjLAYER mountains(jjLayers[7]);
		mountains.yOffset = jjLayerYOffset[7] + (additionalLayerID + 1) * (40 * 32 + 92);
		mountains.xSpeed = jjLayerXSpeed[7] * (4 - additionalLayerID) / 6;
		mountains.ySpeed -= 0.03 * (additionalLayerID + 1);
		layers.insertAt(additionalLayerID + 8, mountains);
	}
	jjLayerOrderSet(layers);
	
	HH24::levelLoad();
	
	jjUseLayer8Speeds = true;
	
	SMOKE::POLARBEAR(OBJECT::FATCHICK,3);
	SMOKE::MECHABEAR(OBJECT::DEMON,4);

	jjObjectPresets[OBJECT::ONEUPCRATE].behavior = GiftBox();
	jjObjectPresets[OBJECT::ONEUPCRATE].determineCurAnim(ANIM::CUSTOM[0], 0);
	
	jjObjectPresets[OBJECT::TRIGGERCRATE].behavior = Crate();
	
	jjAnimSets[ANIM::CUSTOM[51]].load(11, "HH18E1.j2a");
	jjAnimSets[ANIM::CUSTOM[50]].allocate(array<uint> = {jjAnimations[jjAnimSets[ANIM::CUSTOM[50]]].frameCount * 2 - 2});
	pingPongAnimation(jjAnimations[jjAnimSets[ANIM::CUSTOM[51]]], jjAnimations[jjAnimSets[ANIM::CUSTOM[50]]]);
	jjObjectPresets[OBJECT::CRAB].determineCurAnim(ANIM::CUSTOM[51], 0);
	jjObjectPresets[OBJECT::CRAB].energy = 1;
	jjObjectPresets[OBJECT::CRAB].behavior = BEHAVIOR::WALKINGENEMY;
	
	deleteUnwantedEvents();
	
	jjObjectPresets[OBJECT::BAT].behavior = BlueBat();
	
	jjObjectPresets[OBJECT::BIGBOX].deactivates = false;
	jjObjectPresets[OBJECT::BIGBOX].behavior = FasterBox();
}

class BlueBat : jjBEHAVIORINTERFACE {
	void onBehave(jjOBJ@ obj) {
		obj.behave(BEHAVIOR::BAT);
		//obj.determineCurFrame();
		
		int playerID = obj.findNearestPlayer(20000);
		
		if (playerID > -1 && obj.freeze == 0) {
			if (obj.ySpeed != 0) {
				if (jjPlayers[playerID].xPos > int(obj.xPos + 20) && obj.xPos < (obj.xOrg + 96)) {
					obj.xPos += jjDifficulty > 1? 2:1;
					obj.direction = 1;
				}
				else if (jjPlayers[playerID].xPos < int(obj.xPos - 20) && obj.xPos > (obj.xOrg - 96)) {
					obj.xPos -= jjDifficulty > 1? 2:1;
					obj.direction = -1;
				}
				if (jjPlayers[playerID].yPos > obj.yPos && obj.yPos < (obj.yOrg + 96)) obj.yPos += 1;
			}
		}
	}
}

class FasterBox : jjBEHAVIORINTERFACE {
	void onBehave(jjOBJ@ obj) {
		obj.behave(BEHAVIOR::BIGOBJECT);
		int playerID = obj.findNearestPlayer(5000);
		if (obj.xSpeed > 0) {
			obj.xPos += 1;
			if (obj.freeze == 0 || jjPlayers[playerID].keyRight) jjPlayers[playerID].xPos += 1;
		}
		if (obj.xSpeed < 0) {
			obj.xPos -= 1;
			if (obj.freeze == 0 || jjPlayers[playerID].keyLeft) jjPlayers[playerID].xPos -= 1;
		}
		for (int i = 1; i < jjObjectCount; i++) {
			jjOBJ@ obj2 = jjObjects[i];
			if (obj2.eventID == OBJECT::BIGBOX && obj2.doesCollide(obj, true) && obj2.xOrg != obj.xOrg) {
				obj.state = STATE::SLEEP;
				obj.ySpeed = 0;
			}
		}
		
	}
}

void deleteUnwantedEvents() {
    int width = jjLayerWidth[4];
    int height = jjLayerHeight[4] - 1;
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            int event = jjEventGet(j, i);
            if (event == 254)
                jjParameterSet(j, i + 1, -12, 32, 0);
        }
    }
}

void pingPongAnimation(const jjANIMATION@ src, jjANIMATION@ dest) {
	for (uint i = 0; i < src.frameCount; i++) {
		jjAnimFrames[dest + i] = jjAnimFrames[src + i];
	}
	for (uint i = 1; i < src.frameCount - 1; i++) {
		jjAnimFrames[dest + dest.frameCount - i] = jjAnimFrames[src + i];
	}
}

void Lamp(jjOBJ@ obj) {
	if (obj.state == STATE::START) {
		obj.behave(BEHAVIOR::DESTRUCTSCENERY, false);
		if ((jjTileGet(4, uint(obj.xOrg) >> 5, uint(obj.yOrg) >> 5) & TILE::RAWRANGE) == 361) {
			obj.lightType = LIGHT::NORMAL;
			obj.light = 11;
		}
	} else {
		obj.behave(BEHAVIOR::DESTRUCTSCENERY, false);
		if (obj.state == STATE::DONE) {
			obj.lightType = LIGHT::NONE;
			obj.behavior = BEHAVIOR::DESTRUCTSCENERY;
		}
	}
}

void CheckpointWrapper(jjOBJ@ obj) {
	if (obj.state == STATE::STOP) { //don't do anything anymore
		jjDrawSpriteFromCurFrame(obj.xPos, obj.yPos, obj.curFrame);
	} else if (obj.state == STATE::DEACTIVATE) { //due to death
		obj.deactivate();
	} else {
		obj.behave(BEHAVIOR::CHECKPOINT);
		if (obj.state == STATE::DONE) { //triggered by the player hitting it
			obj.state = STATE::STOP;
			//save the current state of some properties
			for (uint i = 0; i < 32; ++i)
				SavedTriggers[i] = jjTriggers[i];
			//OPTIONAL: this loop makes checkpoints reusable, so only the most recent checkpoint you touched is ever active
			for (int i = jjObjectCount; --i > 0;) {
				jjOBJ@ obj2 = jjObjects[i];
				if (obj2.eventID == OBJECT::CHECKPOINT && i != obj.objectID && obj2.isActive) {
					obj2.state = STATE::SLEEP;
					obj2.var[0] = 0;
				}
			}
		}
	}
}


class Crate : jjBEHAVIORINTERFACE {
	void onBehave(jjOBJ@ obj) {
		obj.behave(BEHAVIOR::CRATE, true);
		
		if (obj.state == STATE::KILL) {
			for (uint i = 0; i < 32; ++i) {
				SavedTriggers[i] = jjTriggers[i];
			}
			jjEventSet(uint(obj.xOrg) >> 5, uint(obj.yOrg) >> 5, 0);
		}
	}
}

bool onDrawAmmo(jjPLAYER@ player, jjCANVAS@ canvas) {
	return MLLE::WeaponHook.drawAmmo(player, canvas);
}

void onMain() {
	
	HH24::main();

	array<jjLAYER@> layers = jjLayerOrderGet();
	layers[0].hasTiles = layers[layers.length()-3].hasTiles = layers[layers.length()-4].hasTiles = jjColorDepth == 16 && !jjLowDetail? true:false;

}
 
void onLevelReload() {
	MLLE::SpawnOffgridsLocal();
	MLLE::ReapplyPalette();
	HH24::levelReload();
	jjLocalPlayers[0].lives++;
	
	for (uint i = 0; i < 32; ++i)
		jjTriggers[i] = SavedTriggers[i];
}

void onPlayer(jjPLAYER@ player) {
	
	
	HH24::player(player);
	
	jjIsSnowing = player.lighting > 60? true:false;
}

void onFunction99(jjPLAYER@ play) {
	for (int i = 1; i < jjObjectCount; i++) {
		jjOBJ@ obj = jjObjects[i];
		if (obj.eventID == OBJECT::BIGBOX) {
			jjSamplePriority(SOUND::COMMON_TELPORT2);
			obj.particlePixelExplosion(1);
			obj.xPos = obj.xOrg;
			obj.yPos = obj.yOrg;
			obj.putOnGround(false);
		}
	}
}

void onFunction100(jjPLAYER@ play) {
	HH24::endLevel();
}

bool onDrawScore(jjPLAYER@ player, jjCANVAS@ canvas) {
	HH24::score(player, canvas, true);
	return false;
}

void onLevelBegin() {
	MLLE::SpawnOffgrids();
	
	jjObjectPresets[OBJECT::ELECTROBULLET].animSpeed = 1;
	jjObjectPresets[OBJECT::ELECTROBULLETPU].animSpeed = 1;
	
	for (uint i = 0; i < 4; i++) {
		jjANIMATION@ animBat = jjAnimations[jjAnimSets[ANIM::BAT] + i];
		for (uint j = 0; j < animBat.frameCount; j++) {
			jjANIMFRAME@ frame = jjAnimFrames[animBat + j];
			jjPIXELMAP sprite(frame);
			for (uint x = 0; x < sprite.width; ++x) {
				for (uint y = 0; y < sprite.height; ++y) {
					if (sprite[x,y] >= 88 && sprite[x,y] <= 94) sprite[x,y] -= 57;
				}
				sprite.save(frame);
			}
		}
	}
}