# Regions - My Protocol Extension Approach

``````import Darwin
struct Position { let x, y: Float }
typealias Distance = Float

protocol Region
{
func contains(position: Position) -> Bool
}

// Back to being a struct
struct Circle: Region
{
func contains(position: Position) -> Bool
{
}
}

struct Rectangle: Region
{
let width: Distance
let height: Distance
func contains(position: Position) -> Bool {
return (fabs(position.x) <= width/2
&& fabs(position.y) <= height/2)
}
}

struct ComposedRegion: Region
{
let containsRule: Position -> Bool  ///< holds the complex logic as a function

func contains(position: Position) -> Bool
{
return containsRule(position)
}
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Transformations as protocol extensions

extension Region
{
func shift(by offset: Position) -> Region
{
// TODO: Is it clearer to write them with a "local function", like this?
func hitTest(point: Position) -> Bool {
let shiftedPoint = Position(x: point.x - offset.x, y: point.y - offset.y)
return self.contains(shiftedPoint)
}
return ComposedRegion(containsRule: hitTest)
}

func invert() -> Region
{
return ComposedRegion { point in !self.contains(point) }
}

func intersection(with other: Region) -> Region
{
return ComposedRegion(containsRule: { point in
self.contains(point) && other.contains(point)
})
}

func union(with other: Region) -> Region
{
return ComposedRegion(containsRule: { point in
self.contains(point) || other.contains(point)
})
}

func difference(minus minusRegion: Region) -> Region
{
return self.intersection(with: minusRegion.invert())
}

}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Now, the complex example

let ownPosition = Position(x: 10, y: 12)
let friendlyRegion = safeDistance.shift(by: Position(x: 12, y: 9))

// This is easy enough to follow like this, no need to break into separate steps.
let shouldFireAtTarget = weaponRange
.difference(minus: safeDistance)
.shift(by: ownPosition)
.difference(minus: friendlyRegion)

// Test it
shouldFireAtTarget.contains(Position(x: 0, y: 0))  // too far away
shouldFireAtTarget.contains(Position(x: 9, y: 15))  // hit!
shouldFireAtTarget.contains(Position(x: 10.5, y: 12))  // too close to self
shouldFireAtTarget.contains(Position(x: 12.25, y: 9.25))  // too close to friendly
``````