TEAMMATES CAN DAMAGE

[Auris.]

on damage of player:
    if attacker's world is "bm":
        broadcast "a"
        if {bm.team1::%attacker%} = {bm.team1::%victim%}:
            broadcast "b"
            cancel event
            send "{@prefix} Tu negali žudyti savo komandos nario!" to attacker

 

[White]

Replace = with is

Assuming the variables are not numbers, they must be "is"

 

[Pikachu]

take a look at this team script i was making at some point

#forcibly change teams

options:
  list: teams
  permission: teams.admin
  prefix: <orange>Teams <dark gray>»<light gray>

on script load:
  delete {teams::help::*}

function getPrefix(i: int = 1) :: string:
  return "{@prefix}"

function gP(i: int = 1) :: string:
  return getPrefix()

function isAdmin(player: player) :: boolean:
  return check [{_player} has permission "{@permission}"]

function registerHelp(menu: string, text: string, admin: boolean = false) :: boolean:
  if {teams::help::%{_menu}%} is not set:
    set {teams::help::%{_menu}%} to true
    set {teams::help::%{_menu}%::admin} to {_admin}
    set {teams::help::%{_menu}%::text} to {_text}
    return true
  return false

function isAdminMenu(menu: string) :: boolean:
  return {teams::help::%{_menu}%::admin}

function isValidHelp(menu: string) :: boolean:
  return not ({teams::help::%{_menu}%} == null)

function teamExists(team: int) :: boolean:
  return not ({teams::teams::%{_team}%} == null)

function validateTeam(team: int, function: string) :: boolean:
  if not teamExists({_team}):
    send "[Teams] Team %{_team}% wasn't found, halting function ""%{_function}%""." to console
    return false
  return true

function getHelpText(menu: string) :: string:
  return {teams::help::%{_menu}%::text}

function getTeam(player: player) :: int:
  set {_uuid} to uuid of {_player}
  return {teams::teams::players::%{_uuid}%::current}

function getTeamOf(player: player) :: int:
  return getTeam({_player})

function hasTeam(player: player) :: boolean:
  return not (getTeam({_player}) == null)

function allTeams(i: int = 1) :: ints:
  loop all indexes of {teams::teams::*}:
    add loop-value parsed as an int to {_return::*}
  return {_return::*}

function getPlayers(team: int) :: players:
  return {teams::teams::%{_team}%::players::*}

function setPlayers(team: int, players: objects):
  validateTeam({_team}, "setPlayers") is true
  if {_players::*} is not null ref:
    loop getPlayers({_team}):
      delete {teams::teams::players::%uuid of loop-value%::current}
    delete {teams::teams::%{_team}%::players::*}
    loop {_players::*}:
      loop {teams::teams::%getTeam(loop-value)%::players::*}:
        if loop-value-1 is loop-value-2:
          delete {teams::teams::%getTeam(loop-value-1)%::players::%loop-index-2%} 
      set {teams::teams::players::%uuid of loop-value%::current} to {_team}
    set {teams::teams::%{_team}%::players::*} to {_players::*}
  else:
    loop getPlayers({_team}):
      delete {teams::teams::players::%uuid of loop-value%::current}
      delete {teams::teams::players::%uuid of loop-value%}
    delete {teams::teams::%{_team}%::players::*}

function deletePlayers(team: int):
  setPlayers({_team}, null ref)

function clearTeam(team: int, callEvent: boolean = true):
  validateTeam({_team}, "clearTeam") is true
  if {_callEvent}:
    call custom event "team delete" to details {_team}
    if last called custom event was cancelled:
      stop
  deletePlayers({_team})
  delete {teams::teams::%{_team}%}
  delete {teams::teams::%{_team}%::*}

function clearTeams(callSubEvent: boolean = true):
  call custom event "clear teams"
  if last called custom event wasn't cancelled:
    loop allTeams():
      clearTeam(loop-value, {_callSubEvent})

function clearAllTeams(callSubEvent: boolean = true):
  clearTeams({_callSubEvent})

function teamExists(team: int) :: boolean:
  return not ({teams::teams::%{_team}%} == null)

function addPlayers(players: players, team: int):
  validateTeam({_team}, "addPlayers") is true
  remove all getPlayers({_team}) from {_players::*}
  set {_newPlayers::*} to getPlayers({_team}) and {_players::*}
  setPlayers({_team}, {_newPlayers::*})

function addPlayer(players: players, team: int):
  addPlayers({_players::*}, {_team})

function removePlayers(players: players, team: int):
  validateTeam({_team}, "removePlayers") is true
  set {_currentPlayers::*} to getPlayers({_team})
  remove all {_players::*} from {_currentPlayers::*}
  if {_currentPlayers::*} is set:
    setPlayers({_team}, {_currentPlayers::*})
  else:
    deletePlayers({_team})

function removePlayer(players: players, team: int):
  removePlayers({_players::*}, {_team})

function setTeam(players: players, team: object):
  ({_team} == null ref ? true : (validateTeam({_team}, "setTeam"))) is true
  if {_team} is null ref:
    loop {_players::*}:
      removePlayers(loop-value, getTeam(loop-value))
  else:
    addPlayers({_players::*}, {_team})

function deleteTeam(players: players):
  setTeam({_players::*}, null ref)

function createTeam(callEvent: boolean = true) :: object:
  set {_size} to size of {teams::teams::*}
  if {_callEvent}:
    call custom event "team create" to details {_size}
    if last called custom event was cancelled:
      return null
  set {teams::teams::%{_size}%} to true
  return {_size}

function setFriendlyFire(friendlyFire: boolean):
  set {teams::options::friendlyFire} to {_friendlyFire}

function resetOptions(i: int = 1):
  delete {teams::options::*}

function resetOption(option: string):
  delete {teams::options::%{_option}%}

function friendlyFire(i: int = 1) :: boolean:
  return "%{teams::options::friendlyFire} ? false%" parsed as a boolean

function getFriendlyFire(i: int = 1) :: boolean:
  return friendlyFire()

function setTeamName(team: int, name: string, callEvent: boolean = true):
  validateTeam({_team}, "setTeamName") is true
  call custom event "team name change" details {_team} and {_name}
  if last called custom event wasn't cancelled:
    set {teams::teams::%{_team}%::name} to {_name}

function getTeamName(team: int) :: string:
  return {teams::teams::%{_team}%::name}

function setTeamOwner(team: int, player: player):
  validateTeam({_team}, "setTeamOwner") is true
  set {teams::teams::%{_team}%::owner} to {_player}

function getTeamOwner(team: int) :: player:
  return {teams::teams::%{_team}%::owner}

function isOnTeam(player: player) :: boolean:
  return not (getTeam({_player}) == null)

function areOnSameTeam(players: players) :: boolean:
  loop {_players::*}:
    set {_teams::%getTeam(loop-value)%} to true
  return (size of {_teams::*}) == (1 ? 1)

function onSameTeam(1: player, 2: player) :: boolean:
  set {_players::*} to {_1} and {_2}
  return areOnSameTeam({_players::*})

on damage:
  if onSameTeam(victim and attacker):
    if victim is not attacker:
      call custom event "team damage" details attacker, location of victim, getTeam(victim) and event-world args victim and event
    call custom event "team damage override" details attacker, location of victim, getTeam(victim) and event-world args victim and event

evt "team damage":
  if not friendlyFire():
    cancel the event

evt "team name change":
  broadcast "Team %event-number% tried to change their name to %event-string%"
  cancel the event

evt "team create":
  if random integer from 1 to 100 is greater than 50:
    cancel the event
    broadcast "team creation event cancelled"

evt "team damage":
  broadcast "%event-number% %event-integer% %location%"
  message "Hey %player%, dont hit your teammate!"

evt "team delete":
  broadcast "hey don't do that"
  cancel the event

command /team [<text>] [<text>]:
  aliases: teams
  trigger:
    if arg-1 is "get":
      set {_team} to getTeam(arg-2 parsed as a player)
      if {_team} is set:
        send "%gP()% Team info for %arg-2%:", "%gP()% Name: %getTeamName({_team}) ? ""<red>None""%" and "%gP()% ID: %{_team}%"
      else if arg-2 is set:
        send "%gP()% %arg-2% doesn't have a team"
      else:
        send "%gP()% Please input a player"
    else:
      broadcast "2"