1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#lang rhombus/static
import:
rhombus/random
"chunk.rhm" open
"item.rhm" open
export:
Entity
EntityGatherable
EntityPlayer
ActionResponse
Slot
let rand = random.Random()
class Entity(id:: Int, mutable x :: Int, mutable y :: Int):
nonfinal
// Validate that the provided coordinates are within the max distance range of
// entities current coordinates.
method validate_dist(x :: Int, y :: Int, max_dist :: Int):
let diff_x = math.abs(this.x - x)
let diff_y = math.abs(this.y - y)
// Diagonal case is moving in the same direction (same x & y) and that amount
// is less than or equal to max distance
let diagonal = diff_x == diff_y && diff_x <= max_dist
let x_axis = diff_x <= max_dist && diff_y == 0
let y_axis = diff_y <= max_dist && diff_x == 0
let no_movement = diff_x == 0 && diff_y == 0
!no_movement && (diagonal || x_axis || y_axis)
// Validate that the x,y coordinates map to a chunk that is
// near the current coordinates of the entity
method validate_chunk(x :: Int, y :: Int, current_chunk :: Chunk) :: maybe(Chunk):
let local_x = x - current_chunk.offset_x * current_chunk.width
let local_y = y - current_chunk.offset_y * current_chunk.height
let less_x = local_x < 0
let less_y = local_y < 0
let more_x = local_x >= current_chunk.width
let more_y = local_y >= current_chunk.height
let inside_x = !(less_x || more_x)
let inside_y = !(less_y || more_y)
let next_chunk :: maybe(Chunk) = cond
| inside_x && less_y: current_chunk.neighbours.get(Direction.north, #false)
| more_x && less_y: current_chunk.neighbours.get(Direction.north_east, #false)
| more_x && inside_y: current_chunk.neighbours.get(Direction.east, #false)
| more_x && more_y: current_chunk.neighbours.get(Direction.south_east, #false)
| inside_x && more_y: current_chunk.neighbours.get(Direction.south, #false)
| less_x && more_y: current_chunk.neighbours.get(Direction.south_west, #false)
| less_x && inside_y: current_chunk.neighbours.get(Direction.west, #false)
| less_x && less_y: current_chunk.neighbours.get(Direction.north_west, #false)
| ~else: current_chunk
next_chunk
// Validate that the tile at the coordinates would not block a movement of the entity
// to those coordinates from its current coordinates
method validate_move(x :: Int, y :: Int, max_dist :: Int, current_chunk :: Chunk, target_chunk :: Chunk):
let current_tile = current_chunk.get_tile(this.x, this.y)
let target_tile = target_chunk.get_tile(x, y)
let diff_x = x - this.x
let diff_y = y - this.y
let direction = cond
| diff_x == 0 && diff_y < 0: Direction.north
| diff_x > 0 && diff_y < 0: Direction.north_east
| diff_x > 0 && diff_y == 0: Direction.east
| diff_x > 0 && diff_y > 0: Direction.south_east
| diff_x == 0 && diff_y > 0: Direction.south
| diff_x < 0 && diff_y > 0: Direction.south_west
| diff_x < 0 && diff_y == 0: Direction.west
| diff_x < 0 && diff_y < 0: Direction.north_west
let current_block = current_tile.get_block()
let target_block = flip_block(target_tile.get_block())
!(direction == current_block || direction == target_block)
method
| move(x :: Int, y :: Int, current_chunk :: Chunk): move(x, y, 1, current_chunk)
| move(x :: Int, y :: Int, max_dist :: Int, current_chunk :: Chunk) :: maybe(Chunk):
let target_chunk = validate_chunk(x, y, current_chunk)
cond
| validate_dist(x, y, max_dist) && target_chunk != #false && validate_move(x, y, max_dist, current_chunk, target_chunk!!):
this.x := x
this.y := y
target_chunk!!
| ~else:
#false
class EntityGatherable(quantity :: Int, odds :: Real, cap :: ItemCap):
extends Entity
constructor(id :: Int, x :: Int, y :: Int, cap :: ItemCap):
super(id, x, y)(10, 1 / 10, cap)
enum ActionResponse:
ok
unsuccessful
invalid
cooldown
enum Slot:
right_hand
class EntityPlayer(mutable timer :: Int):
extends Entity
field max_timer = 4
field inventory :: Array.now_of(maybe(Stack)) = Array.make(20, #false)
field equip :: MutableMap.now_of(Slot, Item) = MutableMap()
constructor(id :: Int, x :: Int, y :: Int):
super(id, x, y)(0)
method tick():
// TODO this "ticks" the entity. Things like healing and other
// stuff should happen within here. In the future we probably
// want to set a state where the player is gathering and in tick
// we calculate the odds that they did gather properly
if timer == 0:
| timer := max_timer
| timer := timer - 1
method gather(target_entity :: Entity, current_chunk :: Chunk) :: ActionResponse:
let x = target_entity.x
let y = target_entity.y
let target_chunk = validate_chunk(x, y, current_chunk)
let right_type = target_entity is_a EntityGatherable
fun validate_gather_resource(entity :: EntityGatherable) :: ActionResponse:
let right_tool = item_get_cap(equip.get(Slot.right_hand, #false)) == entity.cap
// TODO odds should change based on skills of player
// we should also validate player is carrying the right tool
// we should also have the timer count down every tick
// not just inside the gathering call
let roll = rand.random()
cond
| !right_tool: ActionResponse.invalid
| rand.random() < entity.odds: ActionResponse.ok
| ~else: ActionResponse.unsuccessful
cond
| timer != 0: ActionResponse.cooldown
| right_type && validate_dist(x, y, 1) && target_chunk != #false:
validate_gather_resource(target_entity)
| ~else:
ActionResponse.invalid
|
