17 |
18 |
19 | 
20 |
21 |
22 |
29 |
30 |
31 |
32 |
--------------------------------------------------------------------------------
/mfm-js/dist/src/elements/agents/SwapWorm.d.ts:
--------------------------------------------------------------------------------
1 | import { Element, IElementType } from '../../mfm/Element';
2 | import { EventWindow, EWIndex } from '../../mfm/EventWindow';
3 |
4 | export declare class SwapWorm extends Element {
5 | static CREATE: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
6 | static SMOLSW: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
7 | static BIGSW: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
8 | constructor(type: IElementType, state?: any);
9 | init(): void;
10 | behave(ew: EventWindow): boolean;
11 | establishType(ew: EventWindow): string;
12 | isHead(): boolean;
13 | isTail(): boolean;
14 | isMiddle(): boolean;
15 | isTemp(): boolean;
16 | confirmBehind(ew: EventWindow): boolean;
17 | confirmAhead(ew: EventWindow): boolean;
18 | isBehindTemp(ew: EventWindow): boolean;
19 | isAheadTemp(ew: EventWindow): boolean;
20 | makeGrowSegment(a: EWIndex): Element;
21 | makeGrowTemp(a: EWIndex): Element;
22 | getSegment(ew: EventWindow, segIndex: EWIndex): Element;
23 | swapSegments(ew: EventWindow, segIndex: EWIndex): boolean;
24 | grow(ew: EventWindow): boolean;
25 | move(ew: EventWindow): boolean;
26 | }
27 |
--------------------------------------------------------------------------------
/mfm-js/dist/src/elements/core/SwapLine.d.ts:
--------------------------------------------------------------------------------
1 | import { Element, IElementType } from '../../mfm/Element';
2 | import { EventWindow } from '../../mfm/EventWindow';
3 |
4 | export declare class SwapLine extends Element {
5 | static CREATE: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
6 | static NORTH: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
7 | static SOUTH: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
8 | static EAST: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
9 | static WEST: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
10 | static NW: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
11 | static NE: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
12 | static SW: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
13 | static SE: (_typeDefinition?: import('../../mfm/Element').IElementTypePartial, _state?: any) => Element;
14 | constructor(type: IElementType, state?: any);
15 | init(): void;
16 | behave(ew: EventWindow): void;
17 | }
18 |
--------------------------------------------------------------------------------
/mfm-js/src/elements/core/DReg.ts:
--------------------------------------------------------------------------------
1 | import { Element, IElementType } from "../../mfm/Element";
2 | import { EventWindow, EWIndex } from "../../mfm/EventWindow";
3 | import { Res } from "./Res";
4 |
5 | export class DReg extends Element {
6 | static CREATE = DReg.CREATOR(
7 | { name: "DREG", class: DReg, color: 0xff2020, groups: ["MFM"] },
8 | {
9 | pDREG_CREATE: 1000,
10 | pRES_CREATE: 200,
11 | pDREG_DESTROY: 10,
12 | pANY_DESTROY: 100,
13 | }
14 | );
15 |
16 | constructor(type: IElementType, state: any = {}) {
17 | super(type, state);
18 | }
19 |
20 | behave(ew: EventWindow) {
21 | super.behave(ew);
22 |
23 | const neighbor: EWIndex = ew.filter(EventWindow.ADJACENT4WAY, null, true)[0];
24 |
25 | if (ew.is(neighbor, "EMPTY")) {
26 | const createDReg: boolean = EventWindow.oneIn(this.state.pDREG_CREATE);
27 | const createRes: boolean = EventWindow.oneIn(this.state.pRES_CREATE);
28 |
29 | if (createDReg) {
30 | ew.move(neighbor, DReg.CREATE());
31 | } else if (createRes) {
32 | ew.move(neighbor, Res.CREATE());
33 | } else {
34 | ew.swap(neighbor);
35 | }
36 | } else if ((ew.is(neighbor, "DREG") && EventWindow.oneIn(this.state.pDREG_DESTROY)) || EventWindow.oneIn(this.state.pANY_DESTROY)) {
37 | ew.move(neighbor);
38 | }
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/mfmrocks/src/pages/lemmings/_game/elements/Dirt.ts:
--------------------------------------------------------------------------------
1 | import { Element, EventWindow, Sand } from "mfm-js";
2 |
3 | export class Dirt extends Element {
4 | static CREATE = Dirt.CREATOR({ name: "DIRT", class: Dirt, color: 0xcf932b, classifications: ["DIGGABLE"], groups: ["LEMMINGS"] });
5 | static ROCK = Dirt.CREATOR({ name: "ROCK", class: Dirt, color: 0xa14e06, classifications: ["SOLID"], groups: ["LEMMINGS"] });
6 | static MOSS = Dirt.CREATOR({ name: "MOSS", class: Dirt, color: 0x0ac765, classifications: ["SOLID"], groups: ["LEMMINGS"] });
7 |
8 | static TODE_RED = Dirt.CREATOR({ name: "TODE_RED", class: Dirt, color: 0xfe4646, classifications: ["SOLID"], groups: ["LEMMINGS"] });
9 | static TODE_GREEN = Dirt.CREATOR({ name: "TODE_GREEN", class: Dirt, color: 0x00fe81, classifications: ["SOLID"], groups: ["LEMMINGS"] });
10 | static TODE_BLACK = Dirt.CREATOR({ name: "TODE_BLACK", class: Dirt, color: 0x161c28, classifications: ["SOLID"], groups: ["LEMMINGS"] });
11 |
12 | static SAND = Sand.CREATOR({ name: "SAND", symbol: "SND", class: Sand, color: 0xffdd00, classifications: ["SAND", "MOVABLE"], groups: ["LEMMINGS"] });
13 |
14 |
15 |
16 | constructor(type: IElementType, state: any = {}) {
17 | super(type, state);
18 |
19 | this.init();
20 | }
21 |
22 | init() {}
23 |
24 | behave(ew: EventWindow) {
25 | super.behave(ew);
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/mfm-js/dist/src/capabilities/Wayfinding.d.ts:
--------------------------------------------------------------------------------
1 | import { Element } from '../mfm/Element';
2 | import { EventWindow, EWIndex } from '../mfm/EventWindow';
3 | import { Direction } from '../mfm/Wayfinder';
4 |
5 | export declare class Wayfinding {
6 | static NAME: string;
7 | static REVERSE(self: Element): void;
8 | static SLIGHT_LEFT(self: Element): void;
9 | static VEER_LEFT(self: Element): void;
10 | static TURN_LEFT(self: Element): void;
11 | static SLIGHT_RIGHT(self: Element): void;
12 | static VEER_RIGHT(self: Element): void;
13 | static TURN_RIGHT(self: Element): void;
14 | static SLIGHT_RANDOMLY(self: Element): void;
15 | static VEER_RANDOMLY(self: Element): void;
16 | static TURN_RANDOMLY(self: Element): void;
17 | static SET_DIRECTION(self: Element, d: Direction): void;
18 | static MOVE_IN_DIRECTION(ew: EventWindow, self: Element, direction: Direction | Direction[], types?: string | string[], leavingAtom?: Element): boolean;
19 | static MOVE_DIRECTIONALLY(ew: EventWindow, self: Element, types?: string | string[], leavingAtom?: Element): boolean;
20 | static SWAP_IN_DIRECTION(ew: EventWindow, self: Element, direction: Direction | Direction[], types?: string | string[]): boolean;
21 | static SWAP_DIRECTIONALLY(ew: EventWindow, self: Element, types?: string | string[]): boolean;
22 | static DIRECT(ew: EventWindow, s: EWIndex, heading: Direction): boolean;
23 | }
24 |
--------------------------------------------------------------------------------
/mfm-js/dist/src/mfm/Element.d.ts:
--------------------------------------------------------------------------------
1 | import { EventWindow } from './EventWindow';
2 |
3 | export interface IElementType {
4 | name: string;
5 | class: any;
6 | symbol?: string;
7 | color?: number;
8 | CREATE?: Function;
9 | classifications?: string[];
10 | groups?: string[];
11 | }
12 | export interface IElementTypePartial {
13 | symbol?: string;
14 | name?: string;
15 | class?: any;
16 | color?: number;
17 | CREATE?: Function;
18 | classifications?: string[];
19 | groups?: string[];
20 | }
21 | export interface IElement {
22 | TYPE: IElementType;
23 | behave: Function;
24 | state?: any;
25 | }
26 | export declare abstract class Element implements IElement {
27 | static CREATOR(typeDefinition: IElementType, state?: any): (_typeDefinition?: IElementTypePartial, _state?: any) => Element;
28 | static UID: (length?: number) => string;
29 | TYPE: IElementType;
30 | state: any;
31 | classes: Set
20 | 
17 | A Movable Feast Machine Simulator written in JavaScript
18 | 40 |
3 |
38 |
39 |
40 |
158 |
--------------------------------------------------------------------------------
/mfm-js/src/elements/agents/Director.ts:
--------------------------------------------------------------------------------
1 | import { Decay } from "../../capabilities/Decay";
2 | import { Wayfinding } from "../../capabilities/Wayfinding";
3 | import { Element, IElementType } from "../../mfm/Element";
4 | import { EventWindow, EWIndex } from "../../mfm/EventWindow";
5 | import { Direction, Wayfinder } from "../../mfm/Wayfinder";
6 |
7 | export class Director extends Element {
8 | static N = Director.CREATOR(
9 | { name: "DIRECTOR N", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
10 | { pointing: "N", directableTypes: ["DIRECTABLE"] }
11 | );
12 |
13 | static S = Director.CREATOR(
14 | { name: "DIRECTOR S", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
15 | { pointing: "S", directableTypes: ["DIRECTABLE"] }
16 | );
17 |
18 | static E = Director.CREATOR(
19 | { name: "DIRECTOR E", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
20 | { pointing: "E", directableTypes: ["DIRECTABLE"] }
21 | );
22 |
23 | static W = Director.CREATOR(
24 | { name: "DIRECTOR W", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
25 | { pointing: "W", directableTypes: ["DIRECTABLE"] }
26 | );
27 |
28 | static NE = Director.CREATOR(
29 | { name: "DIRECTOR NE", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
30 | { pointing: "NE", directableTypes: ["DIRECTABLE"] }
31 | );
32 |
33 | static NW = Director.CREATOR(
34 | { name: "DIRECTOR NW", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
35 | { pointing: "NW", directableTypes: ["DIRECTABLE"] }
36 | );
37 |
38 | static SW = Director.CREATOR(
39 | { name: "DIRECTOR SW", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
40 | { pointing: "SW", directableTypes: ["DIRECTABLE"] }
41 | );
42 |
43 | static SE = Director.CREATOR(
44 | { name: "DIRECTOR SE", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
45 | { pointing: "SE", directableTypes: ["DIRECTABLE"] }
46 | );
47 |
48 | static NNE = Director.CREATOR(
49 | { name: "DIRECTOR NNE", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
50 | { pointing: "NNE", directableTypes: ["DIRECTABLE"] }
51 | );
52 |
53 | static NNW = Director.CREATOR(
54 | { name: "DIRECTOR NNW", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
55 | { pointing: "NNW", directableTypes: ["DIRECTABLE"] }
56 | );
57 |
58 | static ENE = Director.CREATOR(
59 | { name: "DIRECTOR ENE", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
60 | { pointing: "ENE", directableTypes: ["DIRECTABLE"] }
61 | );
62 |
63 | static WNW = Director.CREATOR(
64 | { name: "DIRECTOR WNW", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
65 | { pointing: "WNW", directableTypes: ["DIRECTABLE"] }
66 | );
67 |
68 | static SSE = Director.CREATOR(
69 | { name: "DIRECTOR SSE", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
70 | { pointing: "SSE", directableTypes: ["DIRECTABLE"] }
71 | );
72 | static SSW = Director.CREATOR(
73 | { name: "DIRECTOR SSW", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
74 | { pointing: "SSW", directableTypes: ["DIRECTABLE"] }
75 | );
76 |
77 | static ESE = Director.CREATOR(
78 | { name: "DIRECTOR ESE", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
79 | { pointing: "ESE", directableTypes: ["DIRECTABLE"] }
80 | );
81 | static WSW = Director.CREATOR(
82 | { name: "DIRECTOR WSW", symbol: "DTR", class: Director, color: 0x670239, classifications: ["DIRECTOR"], groups: ["Agents"] },
83 | { pointing: "WSW", directableTypes: ["DIRECTABLE"] }
84 | );
85 |
86 | static DIRECTORS_MAP: Map
4 | {{ currentLevel.name }}
5 | Lemmings Saved: {{ currentSavedLemmings }} / {{ currentSaveGoal ?? "?" }}
6 |
7 |
8 |
9 |
37 |
10 |
11 |
12 |
13 |
22 |
23 |
14 |
20 |
21 |
24 |
36 | Editor Controls
25 | 29 |
30 |
31 |
32 | {{ brushSize }}
33 |
34 |
35 |
77 |
78 |
79 |
149 |
150 |
151 |
152 |
153 |
154 |
219 |
220 |
221 |
--------------------------------------------------------------------------------
/mfm-js/src/elements/agents/SwapWorm.ts:
--------------------------------------------------------------------------------
1 | import { Wayfinding } from "../../capabilities/Wayfinding";
2 | import { Element, IElementType } from "../../mfm/Element";
3 | import { EventWindow, EWIndex } from "../../mfm/EventWindow";
4 | import { Wayfinder } from "../../mfm/Wayfinder";
5 |
6 | export class SwapWorm extends Element {
7 | static CREATE = SwapWorm.CREATOR({ name: "SWAPWORM", symbol: "SWP", class: SwapWorm, color: 0xbe146f, classifications:["DIRECTIONAL", "DIRECTABLE", "WORM"], groups: ["Life"] });
8 |
9 |
10 | static SMOLSW = SwapWorm.CREATOR({ name: "SMOLSW", symbol: "SWP", class: SwapWorm, color: 0xbe146f, classifications:["SWAPWORM", "DIRECTIONAL", "DIRECTABLE", "WORM"], groups: ["Life"] }, {growCount: 2});
11 | static BIGSW = SwapWorm.CREATOR({ name: "BIGSW", symbol: "SWP", class: SwapWorm, color: 0xbe146f, classifications:["SWAPWORM", "DIRECTIONAL", "DIRECTABLE", "WORM"], groups: ["Life"] }, {growCount: 24});
12 |
13 | // static COLORS = [ 0xff0000, 0xff7f00, 0xffff00, 0x00ff00, 0x0000ff, 0x4b0082, 0x940d3 ];
14 |
15 | constructor(type: IElementType, state: any = {}) {
16 | super(type, state);
17 |
18 | this.init();
19 | }
20 |
21 | init() {
22 | this.state.growCount = this.state.growCount ?? 8;
23 | // this.state.color = SwapWorm.COLORS[~~(Math.random()*SwapWorm.COLORS.length)];
24 | }
25 |
26 | behave(ew: EventWindow) {
27 | super.behave(ew);
28 |
29 | let type = this.establishType(ew);
30 | let moved:boolean = false;
31 |
32 | if(!type && this.state.age > 1) {
33 | ew.destroy();
34 | }
35 |
36 | //GROW
37 | if( this.state.growCount ) {
38 | moved = this.grow(ew);
39 | if( moved ) {
40 | return;
41 | }
42 | }
43 |
44 | switch(type) {
45 |
46 |
47 | case "HEAD":
48 | return this.move(ew);
49 | break;
50 | case "MIDDLE":
51 | if( this.isAheadTemp(ew) ) {
52 | moved = this.swapSegments(ew, this.state.ahead );
53 |
54 | if( moved ) {
55 | return;
56 | }
57 | }
58 | break;
59 | case "TAIL":
60 |
61 | if( this.isTemp() ) {
62 | const ahead = this.getSegment( ew, this.state.ahead );
63 | if( ahead ) {
64 | ahead.state.behind = null;
65 | }
66 | ew.destroy();
67 | } else {
68 | if( this.isAheadTemp(ew) ) {
69 | moved = this.swapSegments(ew, this.state.ahead );
70 |
71 | if( moved ) {
72 | return;
73 | }
74 | }
75 | }
76 |
77 | break;
78 | }
79 |
80 | }
81 |
82 | establishType(ew:EventWindow):string {
83 |
84 | this.confirmBehind(ew);
85 | this.confirmAhead(ew);
86 |
87 | let type = undefined;
88 |
89 | if( this.isHead() ) {
90 | this.state.color = 0xddeeff;
91 | type = "HEAD";
92 | } else if( this.isTail() ) {
93 | // this.state.color = 0xff33ff;
94 | type = "TAIL";
95 | } else if( this.isMiddle() ) {
96 | // this.state.color = 0xcc0066;
97 | type = "MIDDLE";
98 | }
99 |
100 | if( this.isTemp() ) {
101 | // this.state.color = SwapWorm.COLORS[~~(Math.random()*SwapWorm.COLORS.length)];
102 | }
103 |
104 | return type;
105 | }
106 |
107 | isHead():boolean {
108 | return !!(!this.state.ahead && this.state.behind);
109 | }
110 |
111 | isTail():boolean {
112 | return !!( this.state.ahead && !this.state.behind) ;
113 | }
114 |
115 | isMiddle():boolean {
116 | return !!( this.state.ahead && this.state.behind );
117 | }
118 |
119 | isTemp():boolean {
120 | return this.state.temp;
121 | }
122 |
123 | confirmBehind(ew:EventWindow):boolean {
124 | const behind = this.getSegment( ew, this.state.behind );
125 |
126 | if( !behind || (behind && !behind.is('SWAPWORM'))) {
127 | this.state.behind = null;
128 | return false;
129 | }
130 |
131 | return true;
132 | }
133 |
134 | confirmAhead(ew:EventWindow):boolean {
135 | const ahead = this.getSegment( ew, this.state.ahead );
136 |
137 | if( !ahead || (ahead && !ahead.is('SWAPWORM'))) {
138 | this.state.ahead = null;
139 | return false;
140 | }
141 |
142 | return true;
143 | }
144 |
145 | isBehindTemp(ew:EventWindow):boolean {
146 | if( this.state.behind ) {
147 | const behind = this.getSegment( ew, this.state.behind );
148 | if( behind && behind.state.temp ) {
149 | return true;
150 | }
151 | }
152 |
153 | return false;
154 | }
155 |
156 | isAheadTemp(ew:EventWindow):boolean {
157 | if( this.state.ahead ) {
158 | const ahead = this.getSegment( ew, this.state.ahead );
159 | if( ahead && ahead.state.temp ) {
160 | return true;
161 | }
162 | }
163 |
164 | return false;
165 | }
166 |
167 | makeGrowSegment( a:EWIndex ):Element {
168 | return SwapWorm.CREATE(this.TYPE, { growCount: 0, ahead: a, behind: this.state.behind })
169 | }
170 |
171 | makeGrowTemp( a:EWIndex):Element {
172 | return SwapWorm.CREATE(this.TYPE, { growCount: 0, ahead: a, behind: this.state.behind, temp: true })
173 | }
174 |
175 | getSegment( ew:EventWindow, segIndex:EWIndex ):Element {
176 |
177 | if( !segIndex && segIndex !== 0 ) {
178 | return undefined;
179 | }
180 |
181 | const seg = ew.getSite(segIndex)?.atom;
182 |
183 | if( !seg || !seg.is("SWAPWORM") ) {
184 | return undefined;
185 | }
186 |
187 | return seg;
188 | }
189 |
190 | swapSegments( ew:EventWindow, segIndex:EWIndex ) {
191 | const segElement:Element = this.getSegment( ew, segIndex );
192 | [this.state.ahead, this.state.behind, segElement.state.ahead, segElement.state.behind] = [ segElement.state.ahead, segElement.state.behind, this.state.ahead, this.state.behind ];
193 | return ew.swap(segIndex);
194 | }
195 |
196 | grow(ew:EventWindow):boolean {
197 |
198 | const moveSite:EWIndex = Math.min( ...ew.filter( EventWindow.ADJACENT8WAY, "EMPTY") ) as EWIndex;
199 |
200 | if( moveSite && moveSite !== Infinity ) {
201 | const moved = ew.move( moveSite, this.makeGrowSegment( moveSite ) );
202 |
203 | if( moved ) {
204 | this.state.growCount--;
205 | this.state.behind = EventWindow.OPPOSITES[moveSite];
206 | }
207 |
208 | return moved;
209 | }
210 |
211 | return false;
212 | }
213 |
214 | move( ew:EventWindow ):boolean {
215 |
216 | if( this.state?.status === "HELD" ) {
217 | return false;
218 | }
219 |
220 | if (!this.state.heading) {
221 | Wayfinding.SET_DIRECTION(this, Wayfinder.RANDOM());
222 | } else if (EventWindow.oneIn(2)) {
223 |
224 |
225 | const travelTo: EWIndex = Wayfinder.getDirectionalMove(this.state.heading, true);
226 | let moved = false;
227 |
228 | if( ew.is(travelTo, "EMPTY") ) {
229 | moved = ew.move(travelTo, this.makeGrowTemp(travelTo) );
230 | }
231 |
232 | if( !(this.state?.status === "DIRECTED") ) {
233 | EventWindow.oneIn(10) && Wayfinding.SLIGHT_RANDOMLY(this);
234 | }
235 |
236 | if( !moved ) {
237 | Wayfinding.SLIGHT_RANDOMLY(this);
238 | } else {
239 | this.state.behind = EventWindow.OPPOSITES[travelTo];
240 | }
241 |
242 | return moved;
243 | }
244 |
245 | return false;
246 |
247 | }
248 | }
249 |
--------------------------------------------------------------------------------
/mfmrocks/src/components/mfms.vue:
--------------------------------------------------------------------------------
1 |
2 |
80 |
147 |
148 |
81 |
90 |
82 |
84 |
85 |
86 |
88 |
89 |
91 |
100 |
92 |
94 |
95 |
96 |
98 |
99 |
101 |
110 |
102 |
104 |
105 |
106 |
108 |
109 |
111 |
114 | My ID: {{tileId}}
112 |{{lastMessage}}
113 |
115 |
124 |
116 |
118 |
119 |
120 |
122 |
123 |
125 |
135 |
126 |
127 |
128 |
129 |
130 |
133 |
134 |
136 |
146 |
137 |
139 |
140 |
141 |
144 |
145 |
3 |
4 |
5 |
53 |
54 |
55 |
56 |
176 |
177 |
304 |
305 |
306 |
--------------------------------------------------------------------------------
/mfm-js/src/elements/agents/HardCell3.ts:
--------------------------------------------------------------------------------
1 | import { Wayfinding } from "../../capabilities/Wayfinding";
2 | import { Element, IElementType } from "../../mfm/Element";
3 | import { EventWindow, EWIndex } from "../../mfm/EventWindow";
4 | import { Direction } from "../../mfm/Wayfinder";
5 |
6 | export class HardCell3 extends Element {
7 | static CREATE = HardCell3.CREATOR({ name: "HARDCELL3x16", symbol: "HC3", class: HardCell3, color: 0xbe146f, classifications: ["HARDCELL3"], groups: ["MFM"] });
8 | static HC3x8 = HardCell3.CREATOR({ name: "HARDCELL3x8", symbol: "HC3", class: HardCell3, color: 0xbe146f, classifications: ["HARDCELL3"], groups: ["MFM"] }, { maxHops: 8});
9 | static HC3x4 = HardCell3.CREATOR({ name: "HARDCELL3x4", symbol: "HC3", class: HardCell3, color: 0xbe146f, classifications: ["HARDCELL3"], groups: ["MFM"] }, { maxHops: 4});
10 |
11 | // static CELL_SITES:EWIndex[] = [37, 38, 39, 40]; //HardCell4
12 | static CELL_SITES:EWIndex[] = [21,22,23,24];
13 | // static CELL_SITES:EWIndex[] = [9,10,11,12]; //HardCell2
14 | // static CELL_SITES:EWIndex[] = [1,2,3,4]; //HardCell1
15 |
16 | static CELL_WANDER_MAP = new Map
6 |
7 |
52 |
8 |
51 |
9 |
50 |
10 |
21 |
25 |
31 |
32 | 33 | 34 | 35 |
36 |
37 |
38 |
39 |
40 |
11 |
15 |
16 |
20 | 32 | 33 | 34 | 35 |
-
41 |
-
42 |
{{key}}
43 | 47 |
48 |