327 lines
8.4 KiB
Plaintext
Executable File
327 lines
8.4 KiB
Plaintext
Executable File
#!/usr/bin/env moon
|
|
utils = require 'utils'
|
|
Game = require 'nomic'
|
|
core_game = require 'core'
|
|
|
|
game = Game(core_game)
|
|
|
|
game\def "# $key $relation = $value", (args)=>
|
|
--print "Setting #{args.key} #{args.relation} = #{args.value}"
|
|
@relations[args.relation][args.key] = args.value
|
|
return args.value
|
|
|
|
game\def "set all * $relation = $value", (args)=>
|
|
rels = @relations[args.relation]
|
|
for k,_ in pairs rels
|
|
rels[k] = args.value
|
|
if next(rels) == nil
|
|
@relations[args.relation] = nil
|
|
return args.value
|
|
|
|
game\def "$key $relation ?", (args)=>
|
|
return @relations[args.relation][args.key]
|
|
|
|
deep_pairs = (t)->
|
|
coroutine.wrap ->
|
|
for k,v in pairs(t)
|
|
coroutine.yield k, v
|
|
mt = getmetatable(t)
|
|
return unless mt and mt.__index and type(mt.__index) == 'table' and mt.__index != t
|
|
for k,v in deep_pairs mt.__index
|
|
if t[k] == nil
|
|
coroutine.yield k,v
|
|
|
|
game\def "* $relation = $value", (args)=>
|
|
--print "Finding all * #{args.relation} = #{args.value}"
|
|
[key for key, value in deep_pairs(@relations[args.relation]) when value == args.value]
|
|
|
|
game\def {"restrict $actions to $whitelist"}, (args)=>
|
|
with args
|
|
actions = @canonicalize(if type(.actions) == 'table' then .actions else {.actions})
|
|
whitelist = @all_aliases(if type(.whitelist) == 'table' then .whitelist else {.whitelist})
|
|
@\set_whitelist actions, whitelist
|
|
for action in *actions
|
|
print("Restricting #{utils.repr(action)} to #{utils.repr(whitelist)}")
|
|
|
|
game\def {"permit $whitelist to $actions"}, (args)=>
|
|
with args
|
|
actions = @canonicalize(if type(.actions) == 'table' then .actions else {.actions})
|
|
whitelist = @all_aliases(if type(.whitelist) == 'table' then .whitelist else {.whitelist})
|
|
for action in *actions
|
|
if not @authorized[action]
|
|
print "#{action} is already available to everyone."
|
|
continue
|
|
print("Permitting #{utils.repr(action)} to #{utils.repr(whitelist)}")
|
|
for w in *whitelist
|
|
@authorized[action][w] = true
|
|
|
|
game\def {"revoke $actions rights from $whitelist"}, (args)=>
|
|
with args
|
|
actions = @canonicalize(if type(.actions) == 'table' then .actions else {.actions})
|
|
whitelist = @all_aliases(if type(.whitelist) == 'table' then .whitelist else {.whitelist})
|
|
for action in *actions
|
|
if not @authorized[action]
|
|
print "#{action} is available to everyone, it can't be restricted."
|
|
continue
|
|
print("Revoking the right of #{utils.repr(action)} to use #{utils.repr(whitelist)}")
|
|
for w in *whitelist
|
|
@authorized[action][w] = nil
|
|
|
|
game\def "print callstack", (args)=>
|
|
print("Callstack:")
|
|
for fn in *@callstack
|
|
print fn
|
|
|
|
game\def {"do $action"}, (args)=>
|
|
(args.action)(@, {})
|
|
|
|
game\def {"make $who $action"}, (args)=>
|
|
with args
|
|
old_you = @you
|
|
print("Setting you=#{.who}")
|
|
rawset(@, "you", .who)
|
|
(.action)(@, {})
|
|
rawset(@, "you", old_you)
|
|
|
|
game\def "you", (args)=> @you
|
|
|
|
game\run[=[
|
|
say "===================================================="
|
|
say " NEW GAME"
|
|
say "===================================================="
|
|
"everyone approves $action" := {yes}
|
|
|
|
"sudo $action" := {
|
|
if (everyone approves $action) {
|
|
do $action
|
|
} else {
|
|
say "You do not have the will of the people! >:("
|
|
}
|
|
}
|
|
restrict "$ := $" to "sudo $"
|
|
restrict "make $ $" to "sudo $"
|
|
restrict "set all * $ = $" to "sudo $"
|
|
restrict "# $ $ = $" to "sudo $"
|
|
restrict "restrict $ to $" to "sudo $"
|
|
|
|
sudo {
|
|
"propose $action" := {
|
|
if ("pending proposal" "is" ?) {
|
|
say "Sorry, an action is already pending."
|
|
} else {
|
|
say "Proposing..."
|
|
# "pending proposal" "is" = $action
|
|
}
|
|
}
|
|
"unpropose" := {
|
|
let "pending" = ("pending proposal" "is" ?)
|
|
set all * $pending = (nil)
|
|
# "pending proposal" "is" = (nil)
|
|
}
|
|
|
|
|
|
"mark $who as approving $action" := {
|
|
# $who $action = "approved"
|
|
}
|
|
|
|
"mark $who as rejecting $action" := {
|
|
# $who $action = "rejected"
|
|
}
|
|
|
|
["approve", "vote yes", "vote yea"] := {
|
|
let "pending" = ("pending proposal" "is" ?)
|
|
mark (you) as approving $pending
|
|
say "Voted yes."
|
|
if (everyone approves $pending) {
|
|
sudo $pending
|
|
unpropose
|
|
} else {
|
|
let "approvers" = (# (* $pending = "approved"))
|
|
let "num-players" = (# (players))
|
|
printf [$approvers, "/", $num-players, " players have approved"]
|
|
}
|
|
}
|
|
|
|
["reject", "vote no", "vote nay", "veto", "disapprove"] := {
|
|
let "pending" = ("pending proposal" "is" ?)
|
|
mark (you) as rejecting $pending
|
|
say "Voted no."
|
|
unpropose
|
|
}
|
|
|
|
["players", "everyone", "everybody", "all players"] := {
|
|
* "is a player" = (yes)
|
|
}
|
|
|
|
"join" := {
|
|
# (you) "is a player" = (yes)
|
|
printf ["Welcome to the game, ",(you),"!"]
|
|
}
|
|
permit "unpropose" to "set all * $ = $"
|
|
permit ["join", "mark $ as approving $", "mark $ as rejecting $", "propose $", "unpropose"] to "# $ $ = $"
|
|
restrict "unpropose" to ["approve", "reject"]
|
|
restrict "mark $ as approving $" to ["propose $", "approve"]
|
|
restrict "mark $ as rejecting $" to ["propose $", "reject"]
|
|
|
|
"everyone approves $action" := {
|
|
(# (players)) == (# (* $action = "approved"))
|
|
}
|
|
}
|
|
|
|
join
|
|
|
|
propose {
|
|
say "fart"
|
|
}
|
|
approve
|
|
|
|
|
|
"cheat" := {
|
|
say "CHEATER!!!"
|
|
}
|
|
sudo {
|
|
say "CHEATER!!!"
|
|
}
|
|
|
|
propose {
|
|
# "democracy" "is possible" = (yes)
|
|
if ("democracy" "is possible" ?) {
|
|
say "DEMOCRACY WORKS!!!"
|
|
}
|
|
}
|
|
approve
|
|
|
|
propose {
|
|
"fart" := {
|
|
say "poot"
|
|
}
|
|
say "fart should have been defined"
|
|
}
|
|
approve
|
|
say "doop"
|
|
fart
|
|
|
|
propose {
|
|
"open election $candidates" := {
|
|
if ("candidates" "are" ?) {
|
|
say "An election is already in progress."
|
|
} else {
|
|
# "candidates" "are" = $candidates
|
|
}
|
|
}
|
|
|
|
"close election" := {
|
|
let "pending" = ("pending proposal" "is" ?)
|
|
set all * "votes for" = (nil)
|
|
# "candidates" "are" = (nil)
|
|
}
|
|
|
|
"vote for $candidate" := {
|
|
# (you) "votes for" = $candidate
|
|
let "vote-percent" = ((# (* "votes for" = $candidate)) / (# (players)))
|
|
printf ["Vote cast. ",$candidate," now has ",(100 * $vote-percent),"% of the votes."]
|
|
if ($vote-percent > 0.5) {
|
|
printf ["The winner of the election is:", $candidate]
|
|
close election
|
|
}
|
|
}
|
|
|
|
permit ["open election $", "close election", "vote for $"] to ["# $ $ = $"]
|
|
permit ["close election"] to ["set all * $ = $"]
|
|
}
|
|
approve
|
|
|
|
propose {
|
|
"as bill: $action" := {
|
|
if ((you) == "Anonymous") {
|
|
make "bill" $action
|
|
} else {
|
|
printf ["Who do you think you are?", (you)]
|
|
}
|
|
}
|
|
permit ["as bill: $"] to ["make $ $"]
|
|
}
|
|
approve
|
|
as bill: {join}
|
|
|
|
propose {
|
|
"as dave: $action" := {
|
|
if ((you) == "Anonymous") {
|
|
make "dave" $action
|
|
} else {
|
|
printf ["Who do you think you are?", (you)]
|
|
}
|
|
}
|
|
permit ["as dave: $"] to ["make $ $"]
|
|
}
|
|
approve
|
|
as bill: {approve}
|
|
as dave: {join}
|
|
|
|
open election ["tom", "dick", "harry"]
|
|
vote for "dick"
|
|
as bill: {vote for "dick"}
|
|
|
|
propose {
|
|
"take a shit" := {say "shit taken."}
|
|
}
|
|
approve
|
|
as bill: {approve}
|
|
as dave: {approve}
|
|
|
|
|
|
|
|
sudo {
|
|
"everyone approves" := {
|
|
(# (players)) == (# (* "votes" (yes)))
|
|
}
|
|
["approve", "vote yes", "vote yea"] := {
|
|
# (you) "votes" = (yes)
|
|
if (everyone approves) {
|
|
do pending action
|
|
}
|
|
}
|
|
["disapprove", "vote no", "vote nay", "veto"] := {
|
|
say "The proposal has failed."
|
|
# (you) "approves" = (yes)
|
|
if (everyone approves) {
|
|
do pending action
|
|
}
|
|
}
|
|
}
|
|
|
|
sudo {
|
|
"everyone approves" := {
|
|
say "Going into this code"
|
|
no
|
|
}
|
|
}
|
|
sudo {
|
|
say "BROKEN"
|
|
}
|
|
|
|
|
|
propose {
|
|
"arbitrarily define $signature := $body" := {
|
|
if ($signature == "butts") {
|
|
$signature := $body
|
|
} else {
|
|
say "Not my style."
|
|
}
|
|
}
|
|
permit "arbitrarily define $ := $" to "$ := $"
|
|
say "Arbitrary is a go."
|
|
}
|
|
as bill: {approve}
|
|
as dave: {approve}
|
|
approve
|
|
arbitrarily define "butts" := {say "BUTTS"}
|
|
butts
|
|
|
|
]=]
|
|
|
|
|
|
|
|
|
|
|