First working version of Family plugin for Craftbukkit server using Josh Cough's excellent Scala wrapper

Family.scala

package com.joshcough.minecraft.examples

import java.util.logging.Logger

import org.bukkit.entity.Player
import org.bukkit.Location
import org.bukkit.event.block.BlockBreakEvent
import org.bukkit.event.player.PlayerMoveEvent
import com.joshcough.minecraft._
import org.bukkit.block.Block

import scala.collection.mutable

class EventThrottle(e: String, p1: String, p2: String, c: scala.Int = 0, t: scala.Long = System.currentTimeMillis) {
  var event: String = e
  var player1: String = p1
  var player2: String = p2
  var time: scala.Long = t
  var count: scala.Int = c

  override def toString = {
    s"$event $player1 $player2 $time $count"
  }
}

object EventThrottle {
  val events = new mutable.MutableList[EventThrottle]()

  // allow the given combination of event/player1/player2 to occur count times within 10 seconds
  def throttle(event: String, player1: String, player2: String):EventThrottle = {
    val ev = events.find((e: EventThrottle) => e.event == event && e.player1 == player1 && e.player2 == player2)
      .getOrElse({
        val new_ev = new EventThrottle(event, player1, player2)
        Logger.getLogger("Minecraft").fine(s"created new EventThrottle: $new_ev")
        events += new_ev
        new_ev})

    // if it's been more than 10 seconds, no events have occurred
    if (ev.time + (1000 * 10) < System.currentTimeMillis) {
      ev.count = 1
      ev.time = System.currentTimeMillis()
      Logger.getLogger("Minecraft").finer(s"EventThrottle timed out: $ev")
    }
    else {
      ev.count += 1
      Logger.getLogger("Minecraft").finest(s"Incremented event: $ev")
    }
    ev
  }

}

/**
 * Notifies you any time someone comes onto your lawn,
 * so that you can yell at them, kick them off, and shock them with lightning.
 *
 * Very similar in functionality to the Arena plugin in this same directory.
 */
class Family extends ListenersPlugin with CommandsPlugin with CubeState {

  val families = new PlayerState[scala.collection.mutable.MutableList[String]] {
    override val default = Some(scala.collection.mutable.MutableList[String]())
  }

  def blockEvent(block:Block , player: Player, event: org.bukkit.event.Cancellable, desc: String) = {
    for ((owner: Player, home) <- cubes; if player != owner && home.contains(block.loc.point)) {
      log.info(s"${player.name} is trying to $desc ${owner.name}'s home")
      owner ! s"${player.name} is trying to $desc your home!"
      event.setCancelled(true)
    }
  }

  val listeners = List(
    OnPlayerMove((p, e) =>
    for ((owner: Player, home) <- cubes; if p.name != owner.name && home.contains(e.getTo.point) ) {
      val ev = EventThrottle.throttle("trespass", owner.name, p.name)
      if (ev.count < 2) {
        owner ! s"${p.name} is trespassing on your home!"
      }
      else
        ev.time = System.currentTimeMillis()
    }
  ),
  OnBlockDamage((block, event) => blockEvent(block, event.getPlayer, event, "damage")),
  OnBlockBreak((block, player, event) => blockEvent(block, player, event, "break")),
  OnPlayerDamageByEntity((player, event) => {

    log.info(s"${player.name} was damaged by ${event.damager}")

      event.damager.whenPlayer(badGuy => {
        log.info(s"${badGuy.name} hurt ${player.name}")
        if (families.state(player) contains badGuy.name) {
          log.info(s"${badGuy.name} is family with ${player.name}, God is not happy")
          badGuy ! s"You hurt your family, God is not pleased!"
          val ev = EventThrottle.throttle("damage", badGuy.name, player.name)
          if (ev.count > 2) {
            badGuy.shockWith("The Lord smiteth thee!")
          }
        }
      }
      )
    }
  ))

  def homeList(p: Player) = {
    for ((owner: Player, home:Cube[Block]) <- cubes) {
      owner ! s"${owner.name} has a home at ${home.corner1} to ${home.corner2}"
    }
  }

  def familyList(p: Player) = {
    for (e <- families(p)) {
      p ! s"${p.name} is family with ${e}"
    }
  }

  val commands = List(
    Command("home1",  "Set the first home position") (p => setFirstPosition(p, p.loc)),
    Command("home2",  "Set the second home position")(p => setSecondPosition(p, p.loc)),
    Command("homeList", "List all player homes")(p => homeList(p)),
    Command("familyList", "List all players' families")(p => familyList(p)),
    Command("goHome", "Go back to your home")(p => {
      // close enough for now
      val home = cube(p)
      p.teleportTo(p.world.getHighestBlockAt(p.world(home.maxX + 2, 0, home.maxZ + 2).loc))
    }),
    Command(
      name = "family",
      desc = "Make players family",
      args = player ~ player)(
        body = {
          case (owner, p1 ~ p2) =>
          {
            log.info(s"making ${p1.name} family with ${p2.name}")
            families(p1) += p2.name
            families(p2) += p1.name
            p1 ! s"You are now family with ${p2.name}"
            p2 ! s"You are now family with ${p1.name}"
          }
        }
      ),
    Command(
      name = "ProtectHome",
      desc = "Kicks everyone out of your home")(
        body = owner => {
          val home = cube(owner)
          for(p <- home.players; if(p != owner)) {
            p.teleportTo(p.world.getHighestBlockAt(p.world(home.maxX + 5, 0, home.maxZ + 5).loc))
            log.info(s"${owner.name} is kicking ${p.name} out of his home")
          }
        }
      )
  )
}

Sadly, Craftbukkit is no more...