SketchyMaze
/
doodads
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
doodads/bird/bird.js

292 lines
7.1 KiB
JavaScript
Raw Normal View History

New Doodad: Blue Bird * The blue bird follows the same base AI as the red bird (it has a target altitude that it tries to maintain, and it will dive at the player) but the blue bird flies in a sine wave pattern around its target altitude. It also has a longer scan radius to search for the player than the red bird. * The sine wave pattern of the blue bird means you may fly under its radar depending how high it is on average. Cheat codes that replace the player character are refactored to make it easier to extend, and new cheats have been added: * super azulian: play as the Red Azulian. * hyper azulian: play as the White Azulian. * bluebird: play as the new Bird (blue).
2022-05-01 00:59:55 +00:00
// Bird (red and blue)
/*
Base A.I. behaviors (red bird) are:
- Tries to maintain original altitude in level and flies left/right.
- Divebombs the player to attack, then climbs back to its original
altitude when it hits a floor/wall.
Blue bird:
- Flies in a sine wave pattern (its target altitude fluctuates
around the bird's original placement on the level).
- Longer aggro radius to dive.
*/
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
let speed = 4,
Level Difficulty + UI Polish Added a new level property: Difficulty * An enum ranging from -1, 0, 1 (Peaceful, Normal, Hard) * Default difficulty is Normal; pre-existing levels are Normal by default per the zero value. Doodad scripts can read the difficulty via the new global variable `Level.Difficulty` and some doodads have been updated: * Azulians: on Peaceful they ignore all player characters, and on Hard they are in "hunt mode": infinite aggro radius and they're aggressive to all characters. * Bird: on Peaceful they will not dive and attack any player character. Other spit and polish: * New Level/Level Properties UI reworked into a magicform. * New "PromptPre(question, answer, func)" function for prompting the user with the developer shell, but pre-filling in an answer for them to either post or edit. * magicform has a PromptUser field option for simple Text/Int fields which present as buttons, so magicform can prompt and update the variable itself. * Don't show the _autosave.doodad in the Doodad Dropper window.
2022-03-07 06:16:09 +00:00
Vx = Vy = 0,
New Doodad: Blue Bird * The blue bird follows the same base AI as the red bird (it has a target altitude that it tries to maintain, and it will dive at the player) but the blue bird flies in a sine wave pattern around its target altitude. It also has a longer scan radius to search for the player than the red bird. * The sine wave pattern of the blue bird means you may fly under its radar depending how high it is on average. Cheat codes that replace the player character are refactored to make it easier to extend, and new cheats have been added: * super azulian: play as the Red Azulian. * hyper azulian: play as the White Azulian. * bluebird: play as the new Bird (blue).
2022-05-01 00:59:55 +00:00
color = Self.GetTag("color"), // informs our A.I. behaviors
searchStep = 12 // pixels to step while searching for a player
searchLimit = color === "blue" ? 24 : 12, // multiples of searchStep for aggro radius
altitude = Self.Position().Y, // original height in level
targetAltitude = altitude; // bird's target height to maintain
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
White Azulian, Respawn invincibility timer * Respawning from a checkpoint grants 3 seconds of immunity in case enemies are spawn camping. * Add the white Azulian as an even faster and harder enemy than the red Azulian: twice as fast, jumps higher, and can detect the player from further away.
2022-01-19 02:32:15 +00:00
let direction = "left",
lastDirection = "left";
let states = {
flying: 0,
diving: 1,
};
let state = states.flying;
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
function main() {
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
Self.SetMobile(true);
Self.SetGravity(false);
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
Self.SetHitbox(0, 0, 46, 32);
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
Self.AddAnimation("fly-left", 100, ["left-1", "left-2"]);
Self.AddAnimation("fly-right", 100, ["right-1", "right-2"]);
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
// Player Character controls?
if (Self.IsPlayer()) {
return player();
}
New sound effects
2023-03-10 06:57:30 +00:00
// No A.I.?
if (Self.GetOption("No A.I.") === true) {
return;
}
Switch JavaScript engine to goja * Switch from otto to goja for JavaScript engine. * goja supports many ES6 syntax features like arrow functions, const/let, for-of with more coming soon. * Same great features as otto, more modern environment for doodads!
2022-01-17 04:09:27 +00:00
Events.OnCollide((e) => {
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
// If we're diving and we hit the player, game over!
if (e.Settled && state === states.diving && e.Actor.IsPlayer()) {
FailLevel("Watch out for birds!");
return;
}
Reset Timer Doodad + Various Fixes * Bird is not solid when colliding with other birds. * If the dev shell is used to run JavaScript during Play Mode, consider it cheating (so player can't `$ d.Scene.ResetTimer()` for example) * On Survival Mode levels, DieByFire immediately opens the End Level (silver score) modal rather than respawn from checkpoint, so levels don't need checkpoint contraptions to end the level. * During level loading screens, wait and call doodads' main() function until the very end.
2022-03-27 18:51:14 +00:00
if (e.Actor.IsMobile() && e.Actor.HasGravity() && e.InHitbox) {
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
return false;
}
});
// Sample our X position every few frames and detect if we've hit a solid wall.
Switch JavaScript engine to goja * Switch from otto to goja for JavaScript engine. * goja supports many ES6 syntax features like arrow functions, const/let, for-of with more coming soon. * Same great features as otto, more modern environment for doodads!
2022-01-17 04:09:27 +00:00
let sampleTick = 0,
sampleRate = 2,
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
lastSampled = Point(0, 0);
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
Switch JavaScript engine to goja * Switch from otto to goja for JavaScript engine. * goja supports many ES6 syntax features like arrow functions, const/let, for-of with more coming soon. * Same great features as otto, more modern environment for doodads!
2022-01-17 04:09:27 +00:00
setInterval(() => {
New Doodad: Blue Bird * The blue bird follows the same base AI as the red bird (it has a target altitude that it tries to maintain, and it will dive at the player) but the blue bird flies in a sine wave pattern around its target altitude. It also has a longer scan radius to search for the player than the red bird. * The sine wave pattern of the blue bird means you may fly under its radar depending how high it is on average. Cheat codes that replace the player character are refactored to make it easier to extend, and new cheats have been added: * super azulian: play as the Red Azulian. * hyper azulian: play as the White Azulian. * bluebird: play as the new Bird (blue).
2022-05-01 00:59:55 +00:00
// Run blue bird A.I. if we are blue: moves our target altitude along a sine wave.
if (color === "blue") {
AI_BlueBird();
}
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
// Sample how far we've moved to detect hitting a wall.
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
if (sampleTick % sampleRate === 0) {
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
let curP = Self.Position()
let delta = Math.abs(curP.X - lastSampled.X);
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
if (delta < 5) {
direction = direction === "right" ? "left" : "right";
}
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
// If we were diving, check Y delta too for if we hit floor
if (state === states.diving && Math.abs(curP.Y - lastSampled.Y) < 5) {
state = states.flying;
}
lastSampled = curP
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
}
sampleTick++;
New sound effects
2023-03-10 06:57:30 +00:00
// Play the bird flap sound if we are on screen.
if (Self.IsOnScreen()) {
Sound.Play("bird-fly.mp3");
}
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
// Are we diving?
if (state === states.diving) {
Vy = speed
} else {
// If we are not flying at our original altitude, correct for that.
let curV = Self.Position();
Vy = 0.0;
New Doodad: Blue Bird * The blue bird follows the same base AI as the red bird (it has a target altitude that it tries to maintain, and it will dive at the player) but the blue bird flies in a sine wave pattern around its target altitude. It also has a longer scan radius to search for the player than the red bird. * The sine wave pattern of the blue bird means you may fly under its radar depending how high it is on average. Cheat codes that replace the player character are refactored to make it easier to extend, and new cheats have been added: * super azulian: play as the Red Azulian. * hyper azulian: play as the White Azulian. * bluebird: play as the new Bird (blue).
2022-05-01 00:59:55 +00:00
if (curV.Y != targetAltitude) {
Vy = curV.Y < targetAltitude ? 1 : -1;
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
}
// Scan for the player character and dive.
try {
AI_ScanForPlayer()
Level Difficulty + UI Polish Added a new level property: Difficulty * An enum ranging from -1, 0, 1 (Peaceful, Normal, Hard) * Default difficulty is Normal; pre-existing levels are Normal by default per the zero value. Doodad scripts can read the difficulty via the new global variable `Level.Difficulty` and some doodads have been updated: * Azulians: on Peaceful they ignore all player characters, and on Hard they are in "hunt mode": infinite aggro radius and they're aggressive to all characters. * Bird: on Peaceful they will not dive and attack any player character. Other spit and polish: * New Level/Level Properties UI reworked into a magicform. * New "PromptPre(question, answer, func)" function for prompting the user with the developer shell, but pre-filling in an answer for them to either post or edit. * magicform has a PromptUser field option for simple Text/Int fields which present as buttons, so magicform can prompt and update the variable itself. * Don't show the _autosave.doodad in the Doodad Dropper window.
2022-03-07 06:16:09 +00:00
} catch (e) {
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
console.error("Error in AI_ScanForPlayer: %s", e);
}
Condensed Palette, Bird AI Update * The Red Bird now records its original altitude on the level and will try and return there should it accidentally climb up or down a wall. Sometimes goes into a wavy pattern surrounding its original altitude. * Editor UI: in the default (vertical) toolbar, the Palette now has a two column view to show more color choices on screen at once. * User setting added: hide the touch control hints.
2021-10-13 03:49:48 +00:00
}
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
// TODO: Vector() requires floats, pain in the butt for JS,
// the JS API should be friendlier and custom...
Switch JavaScript engine to goja * Switch from otto to goja for JavaScript engine. * goja supports many ES6 syntax features like arrow functions, const/let, for-of with more coming soon. * Same great features as otto, more modern environment for doodads!
2022-01-17 04:09:27 +00:00
let Vx = parseFloat(speed * (direction === "left" ? -1 : 1));
Condensed Palette, Bird AI Update * The Red Bird now records its original altitude on the level and will try and return there should it accidentally climb up or down a wall. Sometimes goes into a wavy pattern surrounding its original altitude. * Editor UI: in the default (vertical) toolbar, the Palette now has a two column view to show more color choices on screen at once. * User setting added: hide the touch control hints.
2021-10-13 03:49:48 +00:00
Self.SetVelocity(Vector(Vx, Vy));
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
// If diving, exit - don't edit animation.
if (state === states.diving) {
Level Difficulty + UI Polish Added a new level property: Difficulty * An enum ranging from -1, 0, 1 (Peaceful, Normal, Hard) * Default difficulty is Normal; pre-existing levels are Normal by default per the zero value. Doodad scripts can read the difficulty via the new global variable `Level.Difficulty` and some doodads have been updated: * Azulians: on Peaceful they ignore all player characters, and on Hard they are in "hunt mode": infinite aggro radius and they're aggressive to all characters. * Bird: on Peaceful they will not dive and attack any player character. Other spit and polish: * New Level/Level Properties UI reworked into a magicform. * New "PromptPre(question, answer, func)" function for prompting the user with the developer shell, but pre-filling in an answer for them to either post or edit. * magicform has a PromptUser field option for simple Text/Int fields which present as buttons, so magicform can prompt and update the variable itself. * Don't show the _autosave.doodad in the Doodad Dropper window.
2022-03-07 06:16:09 +00:00
Self.ShowLayerNamed("dive-" + direction);
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
lastDirection = direction;
return;
}
Animations for Thief + No More Moonwalking * Adds walking animations for the Thief. * Mobile doodads no longer moonwalk: their A.I. used to wait for the animation to finish before setting the appropriate animation, so when it changed directions it would "moonwalk" for a time. Their A.I. is now updated to cancel the animation if they change directions so to immediately play the correct animation.
2021-09-04 02:54:10 +00:00
// If we changed directions, stop animating now so we can
// turn around quickly without moonwalking.
if (direction !== lastDirection) {
Self.StopAnimation();
}
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
if (!Self.IsAnimating()) {
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
Self.PlayAnimation("fly-" + direction, null);
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
}
Animations for Thief + No More Moonwalking * Adds walking animations for the Thief. * Mobile doodads no longer moonwalk: their A.I. used to wait for the animation to finish before setting the appropriate animation, so when it changed directions it would "moonwalk" for a time. Their A.I. is now updated to cancel the animation if they change directions so to immediately play the correct animation.
2021-09-04 02:54:10 +00:00
lastDirection = direction;
Doodads: Warp Doors, Bird, Larger State Blocks * The blue and orange ON/OFF state blocks have all been increased in size to better match the player character (42x42 up from 33x33) * Added a new mob: the Red Bird. It flies back and forth while maintaining its altitude, similar to the Red Azulian. Planned AI behavior is to divebomb the player when it gets close. Dive sprites are included but not yet hooked up in JavaScript. * Warp Doors! (WIP). They have a golden "W" on them and come in three varieties: Brown, Blue and Orange. The blue and orange ones are sensitive to the State Block and will become dotted outlines when inactive (and can not be entered in this state). The door opens for the player character, makes him disappear, then closes again. The plan is it will then warp you to the location of a linked Warp Door elsewhere on the level, but for now it will just make the player re-appear after completing the Close Door animation.
2020-12-30 04:31:35 +00:00
}, 100);
}
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
// A.I. subroutine: scan for the player character.
// The bird scans in a 45 degree angle downwards, if the
// player is seen nearby in that scan it will begin a dive.
White Azulian, Respawn invincibility timer * Respawning from a checkpoint grants 3 seconds of immunity in case enemies are spawn camping. * Add the white Azulian as an even faster and harder enemy than the red Azulian: twice as fast, jumps higher, and can detect the player from further away.
2022-01-19 02:32:15 +00:00
// It's not hostile towards characters that can fly (having
// no gravity).
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
function AI_ScanForPlayer() {
Level Difficulty + UI Polish Added a new level property: Difficulty * An enum ranging from -1, 0, 1 (Peaceful, Normal, Hard) * Default difficulty is Normal; pre-existing levels are Normal by default per the zero value. Doodad scripts can read the difficulty via the new global variable `Level.Difficulty` and some doodads have been updated: * Azulians: on Peaceful they ignore all player characters, and on Hard they are in "hunt mode": infinite aggro radius and they're aggressive to all characters. * Bird: on Peaceful they will not dive and attack any player character. Other spit and polish: * New Level/Level Properties UI reworked into a magicform. * New "PromptPre(question, answer, func)" function for prompting the user with the developer shell, but pre-filling in an answer for them to either post or edit. * magicform has a PromptUser field option for simple Text/Int fields which present as buttons, so magicform can prompt and update the variable itself. * Don't show the _autosave.doodad in the Doodad Dropper window.
2022-03-07 06:16:09 +00:00
// If Peaceful difficulty, do not attack.
if (Level.Difficulty < 0) {
return
}
New Doodad: Blue Bird * The blue bird follows the same base AI as the red bird (it has a target altitude that it tries to maintain, and it will dive at the player) but the blue bird flies in a sine wave pattern around its target altitude. It also has a longer scan radius to search for the player than the red bird. * The sine wave pattern of the blue bird means you may fly under its radar depending how high it is on average. Cheat codes that replace the player character are refactored to make it easier to extend, and new cheats have been added: * super azulian: play as the Red Azulian. * hyper azulian: play as the White Azulian. * bluebird: play as the new Bird (blue).
2022-05-01 00:59:55 +00:00
let stepY = searchStep, // number of pixels to skip
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
stepX = stepY,
New Doodad: Blue Bird * The blue bird follows the same base AI as the red bird (it has a target altitude that it tries to maintain, and it will dive at the player) but the blue bird flies in a sine wave pattern around its target altitude. It also has a longer scan radius to search for the player than the red bird. * The sine wave pattern of the blue bird means you may fly under its radar depending how high it is on average. Cheat codes that replace the player character are refactored to make it easier to extend, and new cheats have been added: * super azulian: play as the Red Azulian. * hyper azulian: play as the White Azulian. * bluebird: play as the new Bird (blue).
2022-05-01 00:59:55 +00:00
limit = stepX * searchLimit, // furthest we'll scan
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
scanX = scanY = 0,
size = Self.Size(),
fromPoint = Self.Position();
// From what point do we begin the scan?
if (direction === 'left') {
stepX = -stepX;
fromPoint.Y += size.H;
} else {
fromPoint.Y += size.H;
fromPoint.X += size.W;
}
scanX = fromPoint.X;
scanY = fromPoint.Y;
for (let i = 0; i < limit; i += stepY) {
scanX += stepX;
scanY += stepY;
for (let actor of Actors.At(Point(scanX, scanY))) {
White Azulian, Respawn invincibility timer * Respawning from a checkpoint grants 3 seconds of immunity in case enemies are spawn camping. * Add the white Azulian as an even faster and harder enemy than the red Azulian: twice as fast, jumps higher, and can detect the player from further away.
2022-01-19 02:32:15 +00:00
if (actor.IsPlayer() && actor.HasGravity()) {
New sound effects
2023-03-10 06:57:30 +00:00
Sound.Play("bird-dive.mp3");
Update Doodad JS API + Hostile mobs New functions are available on the JavaScript API for doodads: * Actors.At(Point) []*Actor: returns actors intersecting a point * Actors.FindPlayer() *Actor: returns the nearest player character * Actors.New(filename string): create a new actor (NOT TESTED YET!) * Self.Grounded() bool: query the grounded status of current actor With this the game's built-in doodads have been revised: * Bird: will now scan 240 pixels diagonally searching for the player character and will dive if seen. The Bird is dangerous while diving. It will return to its original altitude once it touches the ground. * Azulians: the Azulians are now dangerous to player characters but not to the Thief. Azulians will begin to follow the player when they are within the aggro range and will hop if the player is above them to try and overcome obstacles. * Blue Azulian: aggro is (250, 100) jump speed 12 movement 2 * Red Azulian: aggro is (250, 200) jump speed 14 movement 4
2022-01-18 05:28:05 +00:00
state = states.diving;
return;
}
}
}
return;
}
New Doodad: Blue Bird * The blue bird follows the same base AI as the red bird (it has a target altitude that it tries to maintain, and it will dive at the player) but the blue bird flies in a sine wave pattern around its target altitude. It also has a longer scan radius to search for the player than the red bird. * The sine wave pattern of the blue bird means you may fly under its radar depending how high it is on average. Cheat codes that replace the player character are refactored to make it easier to extend, and new cheats have been added: * super azulian: play as the Red Azulian. * hyper azulian: play as the White Azulian. * bluebird: play as the new Bird (blue).
2022-05-01 00:59:55 +00:00
// Sine wave controls for the Blue bird.
var sineLimit = 32,
sineCounter = 0,
sineDirection = 1,
sineFrequency = 5, // every 500ms
sineStep = 16;
// A.I. Subroutine: sine wave pattern (Blue bird).
function AI_BlueBird() {
// The main loop runs on a 100ms interval, control how frequently
// to adjust the bird's target velocity.
if (sineCounter > 0 && (sineCounter % sineFrequency) > 1) {
sineCounter++;
return;
}
sineCounter++;
targetAltitude += sineStep*sineDirection;
// Cap the distance between our starting altitude and sine-wave target.
if (targetAltitude < altitude && altitude - targetAltitude >= sineLimit) {
targetAltitude = altitude - sineLimit;
sineDirection = 1
} else if (targetAltitude > altitude && targetAltitude - altitude >= sineLimit) {
targetAltitude = altitude + sineLimit;
sineDirection = -1
}
}
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
// If under control of the player character.
function player() {
v0.11.0 last minute tweaks * When playing as the Bird, the dive attack is able to destroy other mobile doodads such as Azulians and Thieves. * The Box has been made invulnerable so it can't be destroyed by Anvils or player-controlled Birds. * Bugfixes with pop-up modals: * The quit game confirm modal doesn't appear if another modal is already active on screen. * The Escape key can dismiss Alert and Confirm modals. * Add "Level" menu items to Play Mode to restart the level or retry from the last checkpoint (in case of softlocks, etc.)
2022-02-21 21:09:51 +00:00
let playerSpeed = 12,
diving = false,
falling = false;
// The player can dive by moving downwards and laterally, but
// de-cheese their ability to just sweep across the ground; if
// they aren't seen to be moving downwards, cancel the dive.
let lastPoint = Self.Position();
setInterval(() => {
Level Difficulty + UI Polish Added a new level property: Difficulty * An enum ranging from -1, 0, 1 (Peaceful, Normal, Hard) * Default difficulty is Normal; pre-existing levels are Normal by default per the zero value. Doodad scripts can read the difficulty via the new global variable `Level.Difficulty` and some doodads have been updated: * Azulians: on Peaceful they ignore all player characters, and on Hard they are in "hunt mode": infinite aggro radius and they're aggressive to all characters. * Bird: on Peaceful they will not dive and attack any player character. Other spit and polish: * New Level/Level Properties UI reworked into a magicform. * New "PromptPre(question, answer, func)" function for prompting the user with the developer shell, but pre-filling in an answer for them to either post or edit. * magicform has a PromptUser field option for simple Text/Int fields which present as buttons, so magicform can prompt and update the variable itself. * Don't show the _autosave.doodad in the Doodad Dropper window.
2022-03-07 06:16:09 +00:00
let nowAt = Self.Position();
if (nowAt.Y > lastPoint.Y) {
falling = true;
} else {
falling = false;
}
lastPoint = nowAt;
}, 100);
Checkpoint Flag can Re-assign Player Character Link a Doodad to a Checkpoint Flag (like you would a Start Flag) and crossing the flag will replace the player with that doodad. Multiple checkpoint flags like this can toggle you between characters. * Azulians are now friendly to player characters who have the word "Azulian" in their title. * Improve Bird as the playable character: * Dive animation if the player flies diagonally downwards * Animation loop while hovering in the air instead of pausing * Checkpoint flags don't spam each other on PubSub so much which could sometimes lead to deadlocks! SetPlayerCharacter added to the JavaScript API. The Checkpoint Flag (not the region) can link to a doodad and replace the player character with that linked doodad when you activate the checkpoint: Actors.SetPlayerCharacter(filename string): like "boy.doodad" Add various panic catchers to make JavaScript safer and log issues to console.
2022-01-19 05:24:36 +00:00
Switch JavaScript engine to goja * Switch from otto to goja for JavaScript engine. * goja supports many ES6 syntax features like arrow functions, const/let, for-of with more coming soon. * Same great features as otto, more modern environment for doodads!
2022-01-17 04:09:27 +00:00
Events.OnKeypress((ev) => {
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
Vx = 0;
Vy = 0;
Checkpoint Flag can Re-assign Player Character Link a Doodad to a Checkpoint Flag (like you would a Start Flag) and crossing the flag will replace the player with that doodad. Multiple checkpoint flags like this can toggle you between characters. * Azulians are now friendly to player characters who have the word "Azulian" in their title. * Improve Bird as the playable character: * Dive animation if the player flies diagonally downwards * Animation loop while hovering in the air instead of pausing * Checkpoint flags don't spam each other on PubSub so much which could sometimes lead to deadlocks! SetPlayerCharacter added to the JavaScript API. The Checkpoint Flag (not the region) can link to a doodad and replace the player character with that linked doodad when you activate the checkpoint: Actors.SetPlayerCharacter(filename string): like "boy.doodad" Add various panic catchers to make JavaScript safer and log issues to console.
2022-01-19 05:24:36 +00:00
if (ev.Right) {
direction = "right";
} else if (ev.Left) {
direction = "left";
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
}
Checkpoint Flag can Re-assign Player Character Link a Doodad to a Checkpoint Flag (like you would a Start Flag) and crossing the flag will replace the player with that doodad. Multiple checkpoint flags like this can toggle you between characters. * Azulians are now friendly to player characters who have the word "Azulian" in their title. * Improve Bird as the playable character: * Dive animation if the player flies diagonally downwards * Animation loop while hovering in the air instead of pausing * Checkpoint flags don't spam each other on PubSub so much which could sometimes lead to deadlocks! SetPlayerCharacter added to the JavaScript API. The Checkpoint Flag (not the region) can link to a doodad and replace the player character with that linked doodad when you activate the checkpoint: Actors.SetPlayerCharacter(filename string): like "boy.doodad" Add various panic catchers to make JavaScript safer and log issues to console.
2022-01-19 05:24:36 +00:00
// Dive!
v0.11.0 last minute tweaks * When playing as the Bird, the dive attack is able to destroy other mobile doodads such as Azulians and Thieves. * The Box has been made invulnerable so it can't be destroyed by Anvils or player-controlled Birds. * Bugfixes with pop-up modals: * The quit game confirm modal doesn't appear if another modal is already active on screen. * The Escape key can dismiss Alert and Confirm modals. * Add "Level" menu items to Play Mode to restart the level or retry from the last checkpoint (in case of softlocks, etc.)
2022-02-21 21:09:51 +00:00
if (ev.Down && ev.Right && falling) {
Checkpoint Flag can Re-assign Player Character Link a Doodad to a Checkpoint Flag (like you would a Start Flag) and crossing the flag will replace the player with that doodad. Multiple checkpoint flags like this can toggle you between characters. * Azulians are now friendly to player characters who have the word "Azulian" in their title. * Improve Bird as the playable character: * Dive animation if the player flies diagonally downwards * Animation loop while hovering in the air instead of pausing * Checkpoint flags don't spam each other on PubSub so much which could sometimes lead to deadlocks! SetPlayerCharacter added to the JavaScript API. The Checkpoint Flag (not the region) can link to a doodad and replace the player character with that linked doodad when you activate the checkpoint: Actors.SetPlayerCharacter(filename string): like "boy.doodad" Add various panic catchers to make JavaScript safer and log issues to console.
2022-01-19 05:24:36 +00:00
Self.StopAnimation();
Self.ShowLayerNamed("dive-right");
New sound effects
2023-03-10 06:57:30 +00:00
Sound.Play("bird-dive.mp3");
v0.11.0 last minute tweaks * When playing as the Bird, the dive attack is able to destroy other mobile doodads such as Azulians and Thieves. * The Box has been made invulnerable so it can't be destroyed by Anvils or player-controlled Birds. * Bugfixes with pop-up modals: * The quit game confirm modal doesn't appear if another modal is already active on screen. * The Escape key can dismiss Alert and Confirm modals. * Add "Level" menu items to Play Mode to restart the level or retry from the last checkpoint (in case of softlocks, etc.)
2022-02-21 21:09:51 +00:00
diving = falling;
} else if (ev.Down && ev.Left && falling) {
Checkpoint Flag can Re-assign Player Character Link a Doodad to a Checkpoint Flag (like you would a Start Flag) and crossing the flag will replace the player with that doodad. Multiple checkpoint flags like this can toggle you between characters. * Azulians are now friendly to player characters who have the word "Azulian" in their title. * Improve Bird as the playable character: * Dive animation if the player flies diagonally downwards * Animation loop while hovering in the air instead of pausing * Checkpoint flags don't spam each other on PubSub so much which could sometimes lead to deadlocks! SetPlayerCharacter added to the JavaScript API. The Checkpoint Flag (not the region) can link to a doodad and replace the player character with that linked doodad when you activate the checkpoint: Actors.SetPlayerCharacter(filename string): like "boy.doodad" Add various panic catchers to make JavaScript safer and log issues to console.
2022-01-19 05:24:36 +00:00
Self.StopAnimation();
Self.ShowLayerNamed("dive-left");
New sound effects
2023-03-10 06:57:30 +00:00
Sound.Play("bird-dive.mp3");
v0.11.0 last minute tweaks * When playing as the Bird, the dive attack is able to destroy other mobile doodads such as Azulians and Thieves. * The Box has been made invulnerable so it can't be destroyed by Anvils or player-controlled Birds. * Bugfixes with pop-up modals: * The quit game confirm modal doesn't appear if another modal is already active on screen. * The Escape key can dismiss Alert and Confirm modals. * Add "Level" menu items to Play Mode to restart the level or retry from the last checkpoint (in case of softlocks, etc.)
2022-02-21 21:09:51 +00:00
diving = falling;
Checkpoint Flag can Re-assign Player Character Link a Doodad to a Checkpoint Flag (like you would a Start Flag) and crossing the flag will replace the player with that doodad. Multiple checkpoint flags like this can toggle you between characters. * Azulians are now friendly to player characters who have the word "Azulian" in their title. * Improve Bird as the playable character: * Dive animation if the player flies diagonally downwards * Animation loop while hovering in the air instead of pausing * Checkpoint flags don't spam each other on PubSub so much which could sometimes lead to deadlocks! SetPlayerCharacter added to the JavaScript API. The Checkpoint Flag (not the region) can link to a doodad and replace the player character with that linked doodad when you activate the checkpoint: Actors.SetPlayerCharacter(filename string): like "boy.doodad" Add various panic catchers to make JavaScript safer and log issues to console.
2022-01-19 05:24:36 +00:00
} else if (ev.Right) {
// Fly right.
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
if (!Self.IsAnimating()) {
Self.PlayAnimation("fly-right", null);
}
Vx = playerSpeed;
v0.11.0 last minute tweaks * When playing as the Bird, the dive attack is able to destroy other mobile doodads such as Azulians and Thieves. * The Box has been made invulnerable so it can't be destroyed by Anvils or player-controlled Birds. * Bugfixes with pop-up modals: * The quit game confirm modal doesn't appear if another modal is already active on screen. * The Escape key can dismiss Alert and Confirm modals. * Add "Level" menu items to Play Mode to restart the level or retry from the last checkpoint (in case of softlocks, etc.)
2022-02-21 21:09:51 +00:00
diving = false;
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
} else if (ev.Left) {
Checkpoint Flag can Re-assign Player Character Link a Doodad to a Checkpoint Flag (like you would a Start Flag) and crossing the flag will replace the player with that doodad. Multiple checkpoint flags like this can toggle you between characters. * Azulians are now friendly to player characters who have the word "Azulian" in their title. * Improve Bird as the playable character: * Dive animation if the player flies diagonally downwards * Animation loop while hovering in the air instead of pausing * Checkpoint flags don't spam each other on PubSub so much which could sometimes lead to deadlocks! SetPlayerCharacter added to the JavaScript API. The Checkpoint Flag (not the region) can link to a doodad and replace the player character with that linked doodad when you activate the checkpoint: Actors.SetPlayerCharacter(filename string): like "boy.doodad" Add various panic catchers to make JavaScript safer and log issues to console.
2022-01-19 05:24:36 +00:00
// Fly left.
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
if (!Self.IsAnimating()) {
Self.PlayAnimation("fly-left", null);
}
Vx = -playerSpeed;
v0.11.0 last minute tweaks * When playing as the Bird, the dive attack is able to destroy other mobile doodads such as Azulians and Thieves. * The Box has been made invulnerable so it can't be destroyed by Anvils or player-controlled Birds. * Bugfixes with pop-up modals: * The quit game confirm modal doesn't appear if another modal is already active on screen. * The Escape key can dismiss Alert and Confirm modals. * Add "Level" menu items to Play Mode to restart the level or retry from the last checkpoint (in case of softlocks, etc.)
2022-02-21 21:09:51 +00:00
diving = false;
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
} else {
Checkpoint Flag can Re-assign Player Character Link a Doodad to a Checkpoint Flag (like you would a Start Flag) and crossing the flag will replace the player with that doodad. Multiple checkpoint flags like this can toggle you between characters. * Azulians are now friendly to player characters who have the word "Azulian" in their title. * Improve Bird as the playable character: * Dive animation if the player flies diagonally downwards * Animation loop while hovering in the air instead of pausing * Checkpoint flags don't spam each other on PubSub so much which could sometimes lead to deadlocks! SetPlayerCharacter added to the JavaScript API. The Checkpoint Flag (not the region) can link to a doodad and replace the player character with that linked doodad when you activate the checkpoint: Actors.SetPlayerCharacter(filename string): like "boy.doodad" Add various panic catchers to make JavaScript safer and log issues to console.
2022-01-19 05:24:36 +00:00
// Hover in place.
if (!Self.IsAnimating()) {
Level Difficulty + UI Polish Added a new level property: Difficulty * An enum ranging from -1, 0, 1 (Peaceful, Normal, Hard) * Default difficulty is Normal; pre-existing levels are Normal by default per the zero value. Doodad scripts can read the difficulty via the new global variable `Level.Difficulty` and some doodads have been updated: * Azulians: on Peaceful they ignore all player characters, and on Hard they are in "hunt mode": infinite aggro radius and they're aggressive to all characters. * Bird: on Peaceful they will not dive and attack any player character. Other spit and polish: * New Level/Level Properties UI reworked into a magicform. * New "PromptPre(question, answer, func)" function for prompting the user with the developer shell, but pre-filling in an answer for them to either post or edit. * magicform has a PromptUser field option for simple Text/Int fields which present as buttons, so magicform can prompt and update the variable itself. * Don't show the _autosave.doodad in the Doodad Dropper window.
2022-03-07 06:16:09 +00:00
Self.PlayAnimation("fly-" + direction);
Checkpoint Flag can Re-assign Player Character Link a Doodad to a Checkpoint Flag (like you would a Start Flag) and crossing the flag will replace the player with that doodad. Multiple checkpoint flags like this can toggle you between characters. * Azulians are now friendly to player characters who have the word "Azulian" in their title. * Improve Bird as the playable character: * Dive animation if the player flies diagonally downwards * Animation loop while hovering in the air instead of pausing * Checkpoint flags don't spam each other on PubSub so much which could sometimes lead to deadlocks! SetPlayerCharacter added to the JavaScript API. The Checkpoint Flag (not the region) can link to a doodad and replace the player character with that linked doodad when you activate the checkpoint: Actors.SetPlayerCharacter(filename string): like "boy.doodad" Add various panic catchers to make JavaScript safer and log issues to console.
2022-01-19 05:24:36 +00:00
}
v0.11.0 last minute tweaks * When playing as the Bird, the dive attack is able to destroy other mobile doodads such as Azulians and Thieves. * The Box has been made invulnerable so it can't be destroyed by Anvils or player-controlled Birds. * Bugfixes with pop-up modals: * The quit game confirm modal doesn't appear if another modal is already active on screen. * The Escape key can dismiss Alert and Confirm modals. * Add "Level" menu items to Play Mode to restart the level or retry from the last checkpoint (in case of softlocks, etc.)
2022-02-21 21:09:51 +00:00
diving = false;
Thief and Inventory APIs This commit adds the Thief character with starter graphics (no animations). The Thief walks back and forth and will steal items from other doodads, including the player. For singleton items that have no quantity, like the Colored Keys, the Thief will only steal one if he does not already have it. Quantitied items like the Small Key are always stolen. Flexibility in the playable character is introduced: Boy, Azulian, Bird, and Thief all respond to playable controls. There is not currently a method to enable these apart from modifying balance.PlayerCharacterDoodad at compile time. New and Changed Doodads * Thief: new doodad that walks back and forth and will steal items from other characters inventory. * Bird: has no inventory and cannot pick up items, unless player controlled. Its hitbox has also been fixed so it collides with floors correctly - not something normally seen in the Bird. * Boy: opts in to have inventory. * Keys (all): only gives themselves to actors having inventories. JavaScript API - New functions available * Self.IsPlayer() - returns if the current actor IS the player. * Self.SetInventory(bool) - doodads must opt-in to having an inventory. Keys should only give themselves to doodads having an inventory. * Self.HasInventory() bool * Self.AddItem(filename, qty) * Self.RemoveItem(filename, qty) * Self.HasItem(filename) * Self.Inventory() - returns map[string]int * Self.ClearInventory() * Self.OnLeave(func(e)) now receives a CollideEvent as parameter instead of the useless actor ID. Notably, e.Actor is the leaving actor and e.Settled is always true. Other Changes * Play Mode: if playing as a character which doesn't obey gravity, such as the bird, antigravity controls are enabled by default. If you `import antigravity` you can turn gravity back on. * Doodad collision scripts are no longer run in parallel goroutines. It made the Thief's job difficult trying to steal items in many threads simultaneously!
2021-08-10 05:42:22 +00:00
}
New sound effects
2023-03-10 06:57:30 +00:00
if (!diving) {
Sound.Play("bird-fly.mp3");
}
v0.11.0 last minute tweaks * When playing as the Bird, the dive attack is able to destroy other mobile doodads such as Azulians and Thieves. * The Box has been made invulnerable so it can't be destroyed by Anvils or player-controlled Birds. * Bugfixes with pop-up modals: * The quit game confirm modal doesn't appear if another modal is already active on screen. * The Escape key can dismiss Alert and Confirm modals. * Add "Level" menu items to Play Mode to restart the level or retry from the last checkpoint (in case of softlocks, etc.)
2022-02-21 21:09:51 +00:00
// Player is invulnerable while diving.
Self.SetInvulnerable(diving);
});
Events.OnCollide((e) => {
// If the player is diving at an enemy mob, destroy it.
if (diving && e.Settled && e.Actor.IsMobile() && !e.Actor.Invulnerable()) {
New sound effects
2023-03-10 06:57:30 +00:00
Sound.Play("crumbly-break.mp3");
v0.11.0 last minute tweaks * When playing as the Bird, the dive attack is able to destroy other mobile doodads such as Azulians and Thieves. * The Box has been made invulnerable so it can't be destroyed by Anvils or player-controlled Birds. * Bugfixes with pop-up modals: * The quit game confirm modal doesn't appear if another modal is already active on screen. * The Escape key can dismiss Alert and Confirm modals. * Add "Level" menu items to Play Mode to restart the level or retry from the last checkpoint (in case of softlocks, etc.)
2022-02-21 21:09:51 +00:00
e.Actor.Destroy();
}
});
Switch JavaScript engine to goja * Switch from otto to goja for JavaScript engine. * goja supports many ES6 syntax features like arrow functions, const/let, for-of with more coming soon. * Same great features as otto, more modern environment for doodads!
2022-01-17 04:09:27 +00:00
}