93 |
94 | If you type on the arrow keys on your keyboard the blue square should move in the
95 | corresponding direction. If you type `q` it will exit the game.
96 |
97 | Note that with the Playground API the center of the screen is at `(0, 0)`.
98 |
99 | Simple web application
100 | --------------------------
101 |
102 | To compile this same application for the web, simply do:
103 |
104 | ```bash
105 | $ cd docs/toy-web-example
106 | $ opam install --deps-only --yes .
107 | $ dune build --root .
108 | $ cp _build/default/Toy.bc.js static/
109 | ```
110 | You should then be able to use the web app by going to:
111 | https://aryx.github.io/ocaml-elm-playground/toy-web-example/static/Toy.html
112 |
113 | By default the generated javascript file can be big so to get a smaller one
114 | you can do instead:
115 | ```bash
116 | $ dune build --root . --profile=release
117 | $ cp _build/default/Toy.bc.js static/
118 | ```
119 |
120 | Next steps
121 | ------------
122 |
123 | Read the tutorial at:
124 | https://aryx.github.io/ocaml-elm-playground/elm_playground/index.html
125 |
126 | Look at the code under [examples/](examples/) and [games/](games/).
127 |
128 | Here is a screenshot of the [Tetris](games/Tetris.ml) Playgound game running:
129 | 
131 |
132 | You can see a few more screenshots [here](docs/screenshots/).
133 |
134 | Limitations
135 | ------------
136 |
137 | The web backend is not fully finished yet. Many of the examples and games
138 | do not work fully yet on the web. You've been warned.
139 | Contributions are welcome!
140 |
--------------------------------------------------------------------------------
/core/Basics.ml:
--------------------------------------------------------------------------------
1 | let log s =
2 | Printf.printf "%s" s
3 |
4 | let (/..) = (/)
5 | let (+..) = (+)
6 | let (-..) = (-)
7 | let ( *.. ) = ( * )
8 |
9 | (* prefer float operators as default *)
10 | let (/) = (/.)
11 | let (+) = (+.)
12 | let (-) = (-.)
13 | let ( * ) = ( *. )
14 |
15 | let (round: float -> int) = fun f ->
16 | int_of_float (floor (f +. 0.5))
17 |
18 | let mod_by a b =
19 | b mod a
20 |
21 | let pi = Float.pi
22 | let pi2 = 8. *. atan 1.
23 |
24 | (* was called just degrees in Basics.elm *)
25 | let degrees_to_radians deg =
26 | (deg * pi) / 180.
27 |
28 | let radians_to_degrees rad =
29 | rad * 180. / pi
30 |
31 | let (turns: float -> float) = fun angle_in_turns ->
32 | 2. * pi * angle_in_turns
33 |
34 | let (clamp: 'number -> 'number -> 'number -> 'number) = fun low high number ->
35 | if number < low then
36 | low
37 | else if number > high then
38 | high
39 | else
40 | number
41 |
--------------------------------------------------------------------------------
/core/Color.ml:
--------------------------------------------------------------------------------
1 | type t =
2 | | Hex of string
3 | | Rgb of int * int * int
4 |
5 | let (color_clamp : int -> int) = fun number ->
6 | Basics.clamp 0 255 number
7 |
8 | let (rgb : int -> int -> int -> t) = fun r g b ->
9 | Rgb (color_clamp r, color_clamp g, color_clamp b)
10 |
11 |
12 | let white = Hex "#FFFFFF"
13 | let black = Hex "#000000"
14 |
15 | let red = Hex "#cc0000"
16 | let green = Hex "#73d216"
17 | let blue = Hex "#3465a4"
18 |
19 | let yellow = Hex "#edd400"
20 |
21 | let brown = Hex "#c17d11"
22 |
23 | (*-------------------------------------------------------------------*)
24 | (* Light colors *)
25 | (*-------------------------------------------------------------------*)
26 |
27 | let lightYellow = Hex "#fce94f"
28 | let lightPurple = Hex "#ad7fa8"
29 |
30 | (*-------------------------------------------------------------------*)
31 | (* Dark colors *)
32 | (*-------------------------------------------------------------------*)
33 |
34 | (*-------------------------------------------------------------------*)
35 | (* Shades of grey *)
36 | (*-------------------------------------------------------------------*)
37 |
38 | let gray = Hex "#d3d7cf"
39 |
40 | let darkGray = Hex "#babdb6"
41 |
--------------------------------------------------------------------------------
/core/Keyboard.ml:
--------------------------------------------------------------------------------
1 |
2 | type key = string
3 |
--------------------------------------------------------------------------------
/core/Set.ml:
--------------------------------------------------------------------------------
1 | type 'a t = 'a Set_.t
2 | let empty = Set_.empty
3 | let insert = Set_.add
4 | let remove = Set_.remove
5 |
--------------------------------------------------------------------------------
/core/Set_.ml:
--------------------------------------------------------------------------------
1 | (*pad: taken from set.ml from stdlib ocaml, functor sux: module Make(Ord: OrderedType) = *)
2 | (* with some addons such as from list *)
3 |
4 | (***********************************************************************)
5 | (* *)
6 | (* Objective Caml *)
7 | (* *)
8 | (* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
9 | (* *)
10 | (* Copyright 1996 Institut National de Recherche en Informatique et *)
11 | (* en Automatique. All rights reserved. This file is distributed *)
12 | (* under the terms of the GNU Library General Public License, with *)
13 | (* the special exception on linking described in file ../LICENSE. *)
14 | (* *)
15 | (***********************************************************************)
16 |
17 | (* set.ml 1.18.4.1 2004/11/03 21:19:49 doligez Exp *)
18 |
19 | (* Sets over ordered types *)
20 |
21 | (* pad:
22 | type elt = Ord.t
23 | type t = Empty | Node of t * elt * t * int
24 | and subst all Ord.compare with just compare
25 | *)
26 | type 'elt t = Empty | Node of 'elt t * 'elt * 'elt t * int
27 |
28 | (* Sets are represented by balanced binary trees (the heights of the
29 | children differ by at most 2 *)
30 |
31 | let height = function
32 | | Empty -> 0
33 | | Node (_, _, _, h) -> h
34 |
35 | (* Creates a new node with left son l, value v and right son r.
36 | We must have all elements of l < v < all elements of r.
37 | l and r must be balanced and | height l - height r | <= 2.
38 | Inline expansion of height for better speed. *)
39 |
40 | let create l v r =
41 | let hl =
42 | match l with
43 | | Empty -> 0
44 | | Node (_, _, _, h) -> h
45 | in
46 | let hr =
47 | match r with
48 | | Empty -> 0
49 | | Node (_, _, _, h) -> h
50 | in
51 | Node (l, v, r, if hl >= hr then hl + 1 else hr + 1)
52 |
53 | (* Same as create, but performs one step of rebalancing if necessary.
54 | Assumes l and r balanced and | height l - height r | <= 3.
55 | Inline expansion of create for better speed in the most frequent case
56 | where no rebalancing is required. *)
57 |
58 | let bal l v r =
59 | let hl =
60 | match l with
61 | | Empty -> 0
62 | | Node (_, _, _, h) -> h
63 | in
64 | let hr =
65 | match r with
66 | | Empty -> 0
67 | | Node (_, _, _, h) -> h
68 | in
69 | if hl > hr + 2 then
70 | match l with
71 | | Empty -> invalid_arg "Set.bal"
72 | | Node (ll, lv, lr, _) -> (
73 | if height ll >= height lr then create ll lv (create lr v r)
74 | else
75 | match lr with
76 | | Empty -> invalid_arg "Set.bal"
77 | | Node (lrl, lrv, lrr, _) ->
78 | create (create ll lv lrl) lrv (create lrr v r))
79 | else if hr > hl + 2 then
80 | match r with
81 | | Empty -> invalid_arg "Set.bal"
82 | | Node (rl, rv, rr, _) -> (
83 | if height rr >= height rl then create (create l v rl) rv rr
84 | else
85 | match rl with
86 | | Empty -> invalid_arg "Set.bal"
87 | | Node (rll, rlv, rlr, _) ->
88 | create (create l v rll) rlv (create rlr rv rr))
89 | else Node (l, v, r, if hl >= hr then hl + 1 else hr + 1)
90 |
91 | (* Insertion of one element *)
92 |
93 | let rec add x = function
94 | | Empty -> Node (Empty, x, Empty, 1)
95 | | Node (l, v, r, _) as t ->
96 | let c = compare x v in
97 | if c = 0 then t
98 | else if c < 0 then bal (add x l) v r
99 | else bal l v (add x r)
100 |
101 | (* Same as create and bal, but no assumptions are made on the
102 | relative heights of l and r. *)
103 |
104 | let rec join l v r =
105 | match (l, r) with
106 | | Empty, _ -> add v r
107 | | _, Empty -> add v l
108 | | Node (ll, lv, lr, lh), Node (rl, rv, rr, rh) ->
109 | if lh > rh + 2 then bal ll lv (join lr v r)
110 | else if rh > lh + 2 then bal (join l v rl) rv rr
111 | else create l v r
112 |
113 | (* Smallest and greatest element of a set *)
114 |
115 | let rec min_elt = function
116 | | Empty -> raise Not_found
117 | | Node (Empty, v, _r, _) -> v
118 | | Node (l, _v, _r, _) -> min_elt l
119 |
120 | let rec max_elt = function
121 | | Empty -> raise Not_found
122 | | Node (_l, v, Empty, _) -> v
123 | | Node (_l, _v, r, _) -> max_elt r
124 |
125 | (* Remove the smallest element of the given set *)
126 |
127 | let rec remove_min_elt = function
128 | | Empty -> invalid_arg "Set.remove_min_elt"
129 | | Node (Empty, _v, r, _) -> r
130 | | Node (l, v, r, _) -> bal (remove_min_elt l) v r
131 |
132 | (* Merge two trees l and r into one.
133 | All elements of l must precede the elements of r.
134 | Assume | height l - height r | <= 2. *)
135 |
136 | let merge t1 t2 =
137 | match (t1, t2) with
138 | | Empty, t -> t
139 | | t, Empty -> t
140 | | _, _ -> bal t1 (min_elt t2) (remove_min_elt t2)
141 |
142 | (* Merge two trees l and r into one.
143 | All elements of l must precede the elements of r.
144 | No assumption on the heights of l and r. *)
145 |
146 | let concat t1 t2 =
147 | match (t1, t2) with
148 | | Empty, t -> t
149 | | t, Empty -> t
150 | | _, _ -> join t1 (min_elt t2) (remove_min_elt t2)
151 |
152 | (* Splitting. split x s returns a triple (l, present, r) where
153 | - l is the set of elements of s that are < x
154 | - r is the set of elements of s that are > x
155 | - present is false if s contains no element equal to x,
156 | or true if s contains an element equal to x. *)
157 |
158 | let rec split x = function
159 | | Empty -> (Empty, false, Empty)
160 | | Node (l, v, r, _) ->
161 | let c = compare x v in
162 | if c = 0 then (l, true, r)
163 | else if c < 0 then
164 | let ll, pres, rl = split x l in
165 | (ll, pres, join rl v r)
166 | else
167 | let lr, pres, rr = split x r in
168 | (join l v lr, pres, rr)
169 |
170 | (* Implementation of the set operations *)
171 |
172 | let empty = Empty
173 |
174 | let is_empty = function
175 | | Empty -> true
176 | | _ -> false
177 |
178 | let rec mem x = function
179 | | Empty -> false
180 | | Node (l, v, r, _) ->
181 | let c = compare x v in
182 | c = 0 || mem x (if c < 0 then l else r)
183 |
184 | let singleton x = Node (Empty, x, Empty, 1)
185 |
186 | let rec remove x = function
187 | | Empty -> Empty
188 | | Node (l, v, r, _) ->
189 | let c = compare x v in
190 | if c = 0 then merge l r
191 | else if c < 0 then bal (remove x l) v r
192 | else bal l v (remove x r)
193 |
194 | let rec union s1 s2 =
195 | match (s1, s2) with
196 | | Empty, t2 -> t2
197 | | t1, Empty -> t1
198 | | Node (l1, v1, r1, h1), Node (l2, v2, r2, h2) ->
199 | if h1 >= h2 then
200 | if h2 = 1 then add v2 s1
201 | else
202 | let l2, _, r2 = split v1 s2 in
203 | join (union l1 l2) v1 (union r1 r2)
204 | else if h1 = 1 then add v1 s2
205 | else
206 | let l1, _, r1 = split v2 s1 in
207 | join (union l1 l2) v2 (union r1 r2)
208 |
209 | let rec inter s1 s2 =
210 | match (s1, s2) with
211 | | Empty, _t2 -> Empty
212 | | _t1, Empty -> Empty
213 | | Node (l1, v1, r1, _), t2 -> (
214 | match split v1 t2 with
215 | | l2, false, r2 -> concat (inter l1 l2) (inter r1 r2)
216 | | l2, true, r2 -> join (inter l1 l2) v1 (inter r1 r2))
217 |
218 | let rec diff s1 s2 =
219 | match (s1, s2) with
220 | | Empty, _t2 -> Empty
221 | | t1, Empty -> t1
222 | | Node (l1, v1, r1, _), t2 -> (
223 | match split v1 t2 with
224 | | l2, false, r2 -> join (diff l1 l2) v1 (diff r1 r2)
225 | | l2, true, r2 -> concat (diff l1 l2) (diff r1 r2))
226 |
227 | let rec compare_aux l1 l2 =
228 | match (l1, l2) with
229 | | [], [] -> 0
230 | | [], _ -> -1
231 | | _, [] -> 1
232 | | Empty :: t1, Empty :: t2 -> compare_aux t1 t2
233 | | Node (Empty, v1, r1, _) :: t1, Node (Empty, v2, r2, _) :: t2 ->
234 | let c = compare v1 v2 in
235 | if c <> 0 then c else compare_aux (r1 :: t1) (r2 :: t2)
236 | | Node (l1, v1, r1, _) :: t1, t2 ->
237 | compare_aux (l1 :: Node (Empty, v1, r1, 0) :: t1) t2
238 | | t1, Node (l2, v2, r2, _) :: t2 ->
239 | compare_aux t1 (l2 :: Node (Empty, v2, r2, 0) :: t2)
240 |
241 | let rec subset s1 s2 =
242 | match (s1, s2) with
243 | | Empty, _ -> true
244 | | _, Empty -> false
245 | | Node (l1, v1, r1, _), (Node (l2, v2, r2, _) as t2) ->
246 | let c = compare v1 v2 in
247 | if c = 0 then subset l1 l2 && subset r1 r2
248 | else if c < 0 then subset (Node (l1, v1, Empty, 0)) l2 && subset r1 t2
249 | else subset (Node (Empty, v1, r1, 0)) r2 && subset l1 t2
250 |
251 | let compare s1 s2 = compare_aux [ s1 ] [ s2 ]
252 | let equal s1 s2 = compare s1 s2 = 0
253 |
254 | let rec iter f = function
255 | | Empty -> ()
256 | | Node (l, v, r, _) ->
257 | iter f l;
258 | f v;
259 | iter f r
260 |
261 | let rec fold f s accu =
262 | match s with
263 | | Empty -> accu
264 | | Node (l, v, r, _) -> fold f l (f v (fold f r accu))
265 |
266 | let rec for_all p = function
267 | | Empty -> true
268 | | Node (l, v, r, _) -> p v && for_all p l && for_all p r
269 |
270 | let rec exists p = function
271 | | Empty -> false
272 | | Node (l, v, r, _) -> p v || exists p l || exists p r
273 |
274 | let filter p s =
275 | let rec filt accu = function
276 | | Empty -> accu
277 | | Node (l, v, r, _) -> filt (filt (if p v then add v accu else accu) l) r
278 | in
279 | filt Empty s
280 |
281 | let partition p s =
282 | let rec part ((t, f) as accu) = function
283 | | Empty -> accu
284 | | Node (l, v, r, _) ->
285 | part (part (if p v then (add v t, f) else (t, add v f)) l) r
286 | in
287 | part (Empty, Empty) s
288 |
289 | let rec cardinal = function
290 | | Empty -> 0
291 | | Node (l, _v, r, _) -> cardinal l + 1 + cardinal r
292 |
293 | let rec elements_aux accu = function
294 | | Empty -> accu
295 | | Node (l, v, r, _) -> elements_aux (v :: elements_aux accu r) l
296 |
297 | let elements s = elements_aux [] s
298 | let choose = min_elt
299 |
300 | (* pad: *)
301 | let (of_list : 'a list -> 'a t) =
302 | fun xs -> List.fold_left (fun a e -> add e a) empty xs
303 |
304 | (* martin: *)
305 | let pp pp_elt fmt set =
306 | let pp_comma fmt () = Format.fprintf fmt ",@ " in
307 | Format.fprintf fmt "{%a}"
308 | (Format.pp_print_list ~pp_sep:pp_comma pp_elt)
309 | (elements set)
310 |
--------------------------------------------------------------------------------
/core/Set_.mli:
--------------------------------------------------------------------------------
1 | (*pad: taken from set.ml from stdlib ocaml, functor sux: module Make(Ord: OrderedType) = *)
2 | (* with some addons such as from list *)
3 | (***********************************************************************)
4 | (* *)
5 | (* Objective Caml *)
6 | (* *)
7 | (* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
8 | (* *)
9 | (* Copyright 1996 Institut National de Recherche en Informatique et *)
10 | (* en Automatique. All rights reserved. This file is distributed *)
11 | (* under the terms of the GNU Library General Public License, with *)
12 | (* the special exception on linking described in file ../LICENSE. *)
13 | (* *)
14 | (***********************************************************************)
15 |
16 | (* set.mli 1.32 2004/04/23 10:01:54 xleroy Exp $ *)
17 |
18 | (** Sets over ordered types.
19 |
20 | This module implements the set data structure, given a total ordering
21 | function over the set elements. All operations over sets
22 | are purely applicative (no side-effects).
23 | The implementation uses balanced binary trees, and is therefore
24 | reasonably efficient: insertion and membership take time
25 | logarithmic in the size of the set, for instance.
26 | *)
27 |
28 | (* pad:
29 | module type OrderedType =
30 | sig
31 | type t
32 | (** The type of the set elements. *)
33 | val compare : t -> t -> int
34 | (** A total ordering function over the set elements.
35 | This is a two-argument function [f] such that
36 | [f e1 e2] is zero if the elements [e1] and [e2] are equal,
37 | [f e1 e2] is strictly negative if [e1] is smaller than [e2],
38 | and [f e1 e2] is strictly positive if [e1] is greater than [e2].
39 | Example: a suitable ordering function is the generic structural
40 | comparison function {!Pervasives.compare}. *)
41 | end
42 | (** Input signature of the functor {!Set.Make}. *)
43 | *)
44 | (*
45 | module type S =
46 | sig
47 | *)
48 | (* type elt *)
49 | (** The type of the set elements. *)
50 |
51 | type 'elt t
52 | (** The type of sets. *)
53 |
54 | val empty : 'elt t
55 | (** The empty set. *)
56 |
57 | val is_empty : 'elt t -> bool
58 | (** Test whether a set is empty or not. *)
59 |
60 | val mem : 'elt -> 'elt t -> bool
61 | (** [mem x s] tests whether [x] belongs to the set [s]. *)
62 |
63 | val add : 'elt -> 'elt t -> 'elt t
64 | (** [add x s] returns a set containing all elements of [s],
65 | plus [x]. If [x] was already in [s], [s] is returned unchanged. *)
66 |
67 | val singleton : 'elt -> 'elt t
68 | (** [singleton x] returns the one-element set containing only [x]. *)
69 |
70 | val remove : 'elt -> 'elt t -> 'elt t
71 | (** [remove x s] returns a set containing all elements of [s],
72 | except [x]. If [x] was not in [s], [s] is returned unchanged. *)
73 |
74 | val union : 'elt t -> 'elt t -> 'elt t
75 | (** Set union. *)
76 |
77 | val inter : 'elt t -> 'elt t -> 'elt t
78 | (** Set intersection. *)
79 |
80 | val diff : 'elt t -> 'elt t -> 'elt t
81 | (** Set difference. *)
82 |
83 | val compare : 'elt t -> 'elt t -> int
84 | (** Total ordering between sets. Can be used as the ordering function
85 | for doing sets of sets. *)
86 |
87 | val equal : 'elt t -> 'elt t -> bool
88 | (** [equal s1 s2] tests whether the sets [s1] and [s2] are
89 | equal, that is, contain equal elements. *)
90 |
91 | val subset : 'elt t -> 'elt t -> bool
92 | (** [subset s1 s2] tests whether the set [s1] is a subset of
93 | the set [s2]. *)
94 |
95 | val iter : ('elt -> unit) -> 'elt t -> unit
96 | (** [iter f s] applies [f] in turn to all elements of [s].
97 | The elements of [s] are presented to [f] in increasing order
98 | with respect to the ordering over the type of the elements. *)
99 |
100 | val fold : ('elt -> 'a -> 'a) -> 'elt t -> 'a -> 'a
101 | (** [fold f s a] computes [(f xN ... (f x2 (f x1 a))...)],
102 | where [x1 ... xN] are the elements of [s], in increasing order. *)
103 |
104 | val for_all : ('elt -> bool) -> 'elt t -> bool
105 | (** [for_all p s] checks if all elements of the set
106 | satisfy the predicate [p]. *)
107 |
108 | val exists : ('elt -> bool) -> 'elt t -> bool
109 | (** [exists p s] checks if at least one element of
110 | the set satisfies the predicate [p]. *)
111 |
112 | val filter : ('elt -> bool) -> 'elt t -> 'elt t
113 | (** [filter p s] returns the set of all elements in [s]
114 | that satisfy predicate [p]. *)
115 |
116 | val partition : ('elt -> bool) -> 'elt t -> 'elt t * 'elt t
117 | (** [partition p s] returns a pair of sets [(s1, s2)], where
118 | [s1] is the set of all the elements of [s] that satisfy the
119 | predicate [p], and [s2] is the set of all the elements of
120 | [s] that do not satisfy [p]. *)
121 |
122 | val cardinal : 'elt t -> int
123 | (** Return the number of elements of a set. *)
124 |
125 | val elements : 'elt t -> 'elt list
126 | (** Return the list of all elements of the given set.
127 | The returned list is sorted in increasing order with respect
128 | to the ordering [Ord.compare], where [Ord] is the argument
129 | given to {!Set.Make}. *)
130 |
131 | val min_elt : 'elt t -> 'elt
132 | (** Return the smallest element of the given set
133 | (with respect to the [Ord.compare] ordering), or raise
134 | [Not_found] if the set is empty. *)
135 |
136 | val max_elt : 'elt t -> 'elt
137 | (** Same as {!Set.S.min_elt}, but returns the largest element of the
138 | given set. *)
139 |
140 | val choose : 'elt t -> 'elt
141 | (** Return one element of the given set, or raise [Not_found] if
142 | the set is empty. Which element is chosen is unspecified,
143 | but equal elements will be chosen for equal sets. *)
144 |
145 | val split : 'elt -> 'elt t -> 'elt t * bool * 'elt t
146 | (** [split x s] returns a triple [(l, present, r)], where
147 | [l] is the set of elements of [s] that are
148 | strictly less than [x];
149 | [r] is the set of elements of [s] that are
150 | strictly greater than [x];
151 | [present] is [false] if [s] contains no element equal to [x],
152 | or [true] if [s] contains an element equal to [x]. *)
153 |
154 | val of_list : 'elt list -> 'elt t
155 | (*
156 | end
157 | (** Output signature of the functor {!Set.Make}. *)
158 |
159 | module Make (Ord : OrderedType) : S with type elt = Ord.t
160 | (** Functor building an implementation of the set structure
161 | given a totally ordered type. *)
162 | *)
163 |
164 | (* Pretty-print a set as e.g. {1, 2, 3} *)
165 | val pp :
166 | (Format.formatter -> 'elt -> unit) -> Format.formatter -> 'elt t -> unit
167 |
--------------------------------------------------------------------------------
/core/Time.ml:
--------------------------------------------------------------------------------
1 | type posix = float
2 | let millis_to_posix n =
3 | float_of_int n
4 | let posix_to_millis n =
5 | int_of_float ( n *. 1000.)
6 |
--------------------------------------------------------------------------------
/core/dune:
--------------------------------------------------------------------------------
1 | (library
2 | (public_name elm_core)
3 | (wrapped false)
4 | (libraries
5 | ; commons; was for Set_.ml but now included here
6 | )
7 | ; (preprocess (pps profiling.ppx))
8 | )
9 |
--------------------------------------------------------------------------------
/docs/elm_core/Basics/index.html:
--------------------------------------------------------------------------------
1 |
2 | BasicsColorval rgb : int -> int -> int -> tval white : tval black : tval red : tval green : tval blue : tval yellow : tval brown : tval lightYellow : tval lightPurple : tval gray : tval darkGray : tKeyboardSetTimePlayground_platformval run_app : ('a, 'b) Playground.app -> unitCreate pictures, animations, and games with OCaml!
This is a port of the excellent Elm playground package to OCaml.
This is the package I wanted when I was learning programming. Start by putting shapes on screen and work up to making games. I hope this package will be fun for a broad range of ages and backgrounds!
A picture is a list of shapes. For example, this picture combines a brown rectangle and a green circle to make a tree
open Playground
3 |
4 | let app =
5 | picture [
6 | rectangle brown 40. 200.;
7 | circle green 100.
8 | |> move_up 100.;
9 | ]
10 |
11 | let main = Playground_platform.run_app appPlay around to get familiar with all the different shapes and transformations in the library.
An animation is a list of shapes that changes over time. For example, here is a spinning triangle:
open Playground
12 |
13 | let view time = [
14 | triangle orange 50.
15 | |> rotate (spin 8. time);
16 | ]
17 |
18 | let app = animation view
19 |
20 | let main = Playground_platform.run_app appIt will do a full spin every 8 seconds.
Maybe try making a car with spinning octogons as wheels? Try using Playground.wave to move things back-and-forth? Try using Playground.zigzag to fade things in-and-out?
A game lets you use input from the mouse and keyboard to change your picture. For example, here is a square that moves around based on the arrow keys:
open Playground
21 |
22 | let view _computer (x, y) = [
23 | square blue 40.
24 | |> move x y
25 | ]
26 |
27 | let update computer (x, y) =
28 | (x +. to_x computer.keyboard, y +. to_y computer.keyboard)
29 |
30 | let app =
31 | game view update (0., 0.)
32 |
33 | let main = Playground_platform.run_app appEvery game has three important parts:
memory - Store information. Our example stores (x,y) coordinates.update - Update the memory based on mouse movements, key presses, etc. Our example moves the (x,y) coordinate around based on the arrow keys.view - Turn the memory into a picture. Our example just shows one blue square at the (x,y) coordinate we have been tracking in memory.When you start making fancier games, you will store fancier things in memory. There is a lot of room to develop your programming skills here: Making lists, using records, creating custom types, etc.
I started off trying to make Pong, then worked on games like Breakout and Space Invaders as I learned more and more. It was really fun, and I hope it will be for you as well!
Cmdval none : 'a tSubtype 'msg onesub = | SubTick of Time.posix -> 'msg| SubMouseMove of (float * float) -> 'msg| SubMouseDown of unit -> 'msg| SubMouseUp of unit -> 'msg| SubKeyDown of Keyboard.key -> 'msg| SubKeyUp of Keyboard.key -> 'msgtype 'msg t = 'msg onesub listval on_animation_frame : (Time.posix -> 'msg) -> 'msg tval on_mouse_move : ((float * float) -> 'msg) -> 'msg tval on_mouse_down : (unit -> 'msg) -> 'msg tval on_mouse_up : (unit -> 'msg) -> 'msg tval on_key_down : (Keyboard.key -> 'msg) -> 'msg tval on_key_up : (Keyboard.key -> 'msg) -> 'msg ttype event = | ETick of float| EMouseMove of int * int| EMouseButton of bool| EKeyChanged of bool * Keyboard.keyThe most important module below is elm_playground. 16 |
See examples for very basic examples. 24 |
See toy for the toy example used in the README. 25 |
See also games for more complex examples. 26 |