redscript-mc 1.0.0 → 1.2.0

package/src/stdlib/teams.mcrs

@@ -0,0 +1,68 @@
+// Team management helpers
+// Usage: import "stdlib/teams.mcrs"
+
+/// Create a team with color
+fn create_team(name: string, color: string) {
+    team_add(name);
+    team_option(name, "color", color);
+}
+
+/// Create red team
+fn create_red_team() {
+    team_add("red");
+    team_option("red", "color", "red");
+    team_option("red", "friendlyFire", "false");
+}
+
+/// Create blue team
+fn create_blue_team() {
+    team_add("blue");
+    team_option("blue", "color", "blue");
+    team_option("blue", "friendlyFire", "false");
+}
+
+/// Create green team
+fn create_green_team() {
+    team_add("green");
+    team_option("green", "color", "green");
+    team_option("green", "friendlyFire", "false");
+}
+
+/// Create yellow team
+fn create_yellow_team() {
+    team_add("yellow");
+    team_option("yellow", "color", "yellow");
+    team_option("yellow", "friendlyFire", "false");
+}
+
+/// Add player to team
+fn add_to_team(target: selector, team_name: string) {
+    team_join(target, team_name);
+}
+
+/// Remove player from all teams
+fn remove_from_teams(target: selector) {
+    team_leave(target);
+}
+
+/// Setup standard 2-team game
+fn setup_two_teams() {
+    create_red_team();
+    create_blue_team();
+}
+
+/// Setup 4-team game
+fn setup_four_teams() {
+    create_red_team();
+    create_blue_team();
+    create_green_team();
+    create_yellow_team();
+}
+
+/// Cleanup all teams
+fn cleanup_teams() {
+    team_remove("red");
+    team_remove("blue");
+    team_remove("green");
+    team_remove("yellow");
+}

package/src/stdlib/timer.mcrs

@@ -0,0 +1,72 @@
+// Timer utilities with an OOP-style API.
+//
+// Timer state is stored in scoreboard-backed runtime state. Because RedScript
+// does not yet support dynamic scoreboard player/objective names for impl
+// methods, this API currently uses a single shared runtime slot.
+//
+// The `_id` field is reserved for a future runtime-backed instance identifier.
+// Today it remains `0`, while persistence is shared across Timer values.
+
+struct Timer {
+    _id: int,
+    _duration: int
+}
+
+impl Timer {
+    /// Create a new timer with the given duration in ticks.
+    fn new(duration: int) -> Timer {
+        scoreboard_set("timer_ticks", #rs, 0);
+        scoreboard_set("timer_active", #rs, 0);
+        return { _id: 0, _duration: duration };
+    }
+
+    /// Start or resume the timer.
+    fn start(self) {
+        scoreboard_set("timer_active", #rs, 1);
+    }
+
+    /// Pause the timer.
+    fn pause(self) {
+        scoreboard_set("timer_active", #rs, 0);
+    }
+
+    /// Reset elapsed ticks back to zero.
+    fn reset(self) {
+        scoreboard_set("timer_ticks", #rs, 0);
+    }
+
+    /// Check whether the timer has reached its duration.
+    fn done(self) -> bool {
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+        return ticks >= self._duration;
+    }
+
+    /// Get elapsed ticks.
+    fn elapsed(self) -> int {
+        return scoreboard_get("timer_ticks", #rs);
+    }
+
+    /// Get remaining ticks, clamped at zero.
+    fn remaining(self) -> int {
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+        let left: int = self._duration - ticks;
+
+        if (left > 0) {
+            return left;
+        }
+
+        return 0;
+    }
+
+    /// Manually advance the timer by one tick when active.
+    fn tick(self) {
+        let active: int = scoreboard_get("timer_active", #rs);
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+
+        if (active == 1) {
+            if (ticks < self._duration) {
+                scoreboard_set("timer_ticks", #rs, ticks + 1);
+            }
+        }
+    }
+}

package/src/stdlib/world.mcrs

@@ -0,0 +1,92 @@
+// World manipulation helpers
+
+/// Set time to day
+fn set_day() {
+    time_set(1000);
+}
+
+/// Set time to night
+fn set_night() {
+    time_set(13000);
+}
+
+/// Set time to noon
+fn set_noon() {
+    time_set(6000);
+}
+
+/// Set time to midnight
+fn set_midnight() {
+    time_set(18000);
+}
+
+/// Set weather to clear
+fn weather_clear() {
+    weather("clear");
+}
+
+/// Set weather to rain
+fn weather_rain() {
+    weather("rain");
+}
+
+/// Set weather to thunder
+fn weather_thunder() {
+    weather("thunder");
+}
+
+/// Enable keep inventory
+fn enable_keep_inventory() {
+    gamerule("keepInventory", "true");
+}
+
+/// Disable keep inventory
+fn disable_keep_inventory() {
+    gamerule("keepInventory", "false");
+}
+
+/// Disable mob griefing
+fn disable_mob_griefing() {
+    gamerule("mobGriefing", "false");
+}
+
+/// Disable fire spread
+fn disable_fire_spread() {
+    gamerule("doFireTick", "false");
+}
+
+/// Set difficulty to peaceful
+fn set_peaceful() {
+    difficulty("peaceful");
+}
+
+/// Set difficulty to easy
+fn set_easy() {
+    difficulty("easy");
+}
+
+/// Set difficulty to normal
+fn set_normal() {
+    difficulty("normal");
+}
+
+/// Set difficulty to hard
+fn set_hard() {
+    difficulty("hard");
+}
+
+/// Create barrier wall
+fn barrier_wall(x1: int, y1: int, z1: int, x2: int, y2: int, z2: int) {
+    fill(x1, y1, z1, x2, y2, z2, "minecraft:barrier");
+}
+
+/// Create air (clear area)
+fn clear_area(x1: int, y1: int, z1: int, x2: int, y2: int, z2: int) {
+    fill(x1, y1, z1, x2, y2, z2, "minecraft:air");
+}
+
+/// Create glass dome (hollow)
+fn glass_box(x1: int, y1: int, z1: int, x2: int, y2: int, z2: int) {
+    fill(x1, y1, z1, x2, y2, z2, "minecraft:glass");
+    fill(x1 + 1, y1 + 1, z1 + 1, x2 - 1, y2 - 1, z2 - 1, "minecraft:air");
+}