Skip to content

Instantly share code, notes, and snippets.

@antoniojrossi
Forked from weapp/_Regions_.md
Last active August 29, 2015 14:06
Show Gist options
  • Save antoniojrossi/b8ddd3b5acd89b3095ba to your computer and use it in GitHub Desktop.
Save antoniojrossi/b8ddd3b5acd89b3095ba to your computer and use it in GitHub Desktop.
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
def circle(distance):
return lambda point: (point.x ** 2. + point.y ** 2.) ** (1/2.) < distance
def offset(region, position):
return lambda point: region(Point(x=point.x-position.x, y=point.y-position.y))
def inverse(region):
return lambda point: not region(point)
def intersection(region1, region2):
return lambda point: region1(point) and region2(point)
def diference(region1, region2):
return intersection(region1, inverse(region2))
def target(max_distance, min_distance, friend):
donnut_region = diference(circle(max_distance), circle(min_distance))
friend_region = offset(circle(min_distance), friend)
return diference(donnut_region, friend_region)
region = target(3, 1, Point(2,2))
print region(Point(x=1,y=1))
Point = Struct.new(:x, :y)
def Point(hash)
Point.new(hash[:x], hash[:y])
end
def Region(&block)
block.tap{|b|b.instance_eval{alias :include? :call}}
end
def circle(distance)
Region{|point| (point.x ** 2.0 + point.y ** 2.0) ** (1/2.0) < distance}
end
def offset(region, position)
Region{|point| region.include? Point(x: point.x - position.x, y: point.y - position.y)}
end
def inverse(region)
Region{|point| !region.include? point}
end
def intersection(region1, region2)
Region{|point| region1.include?(point) && region2.include?(point)}
end
def diference(region1, region2)
intersection(region1, inverse(region2))
end
def target(max_distance, min_distance, friend)
donnut_region = diference(circle(max_distance), circle(min_distance))
friend_region = offset(circle(min_distance), friend)
diference(donnut_region, friend_region)
end
region = target(3, 1, Point(x:2,y:2))
puts region.include?(Point(x:1,y:1))
import CoreGraphics
typealias Position = CGPoint
typealias Distance = CGFloat
let minimumDistance : Distance = 2.0
func inRange(target: Position, ownPosition: Position, friendly: Position, range: Distance) -> Bool {
let dx = ownPosition.x - target.x
let dy = ownPosition.y - target.y
let friendlyDx = friendly.x - target.x
let friendlyDy = friendly.y - target.y
return sqrt(dx * dx + dy * dy) <= range && sqrt(dx * dx + dy * dy) >= minimumDistance && (sqrt(friendlyDx * friendlyDx + friendlyDy * friendlyDy) >= minimumDistance)
}
inRange(Position(x: 4.0, y:4.0), Position(x:0.0, y:0.0), Position(x:50.0, y:50.0), 10.0)
typealias Region = Position -> Bool
func circle(radius: Distance) -> Region {
return { point in sqrt(point.x * point.x + point.y * point.y) <= radius }
}
circle(3.0)(Position(x:1.0, y:1.0))
func shift(offset: Position, region: Region) -> Region {
return { point in
let shiftedPoint = Position(x: point.x + offset.x, y: point.y + offset.y)
return region(shiftedPoint)}
}
func intersection(region1 : Region, region2 : Region) -> Region {
return { point in region1(point) && region2(point) }
}
func invert(region: Region) -> Region {
return { point in !region(point) }
}
func difference(region: Region, minusRegion: Region) -> Region {
return intersection(region, invert(minusRegion))
}
func inRangeF(ownPosition: Position, target: Position, friendly: Position, range: Distance) -> Bool {
let targetRegion = shift(ownPosition, difference(circle(range), circle(minimumDistance)))
let friendlyRegion = shift(friendly, circle(minimumDistance))
let resultRegion = difference(targetRegion, friendlyRegion)
return resultRegion(target)
}
inRangeF(Position(x: 4.0, y:4.0), Position(x:0.0, y:0.0), Position(x:50.0, y:50.0), 10.0)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment