puzzle-lib 1.3.0 → 1.6.0

package/src/NavalFlags/NavalFlags.ts

@@ -0,0 +1,293 @@
+import {CharacterImage} from '../Common/CharacterImage';
+import {InlineSvg} from '../Common/InlineSvg';
+
+export class NavalFlags {
+  static readonly instance: NavalFlags = new NavalFlags();
+
+  private readonly _entries: CharacterImage[] = [
+    // tslint:disable:max-line-length (SVG images are messy)
+    new CharacterImage(
+      'A',
+      new InlineSvg(
+        `<path d="M 18,18 H 162 L 126,90 L 162,162 H 18 z" fill="#000094"/>
+      <rect x="18" y="18" width="72" height="144" fill="#fff"/>
+      <path d="M 18,18 H 162 L 126,90 L 162,162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'B',
+      new InlineSvg(
+        '<path d="M 18,18 H 162 L 126,90 L 162,162 H 18 z" fill="#f00" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>',
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'C',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#000094"/>
+      <rect x="18" y="46.8" width="144" height="86.4" fill="#fff"/>
+      <rect x="18" y="75.6" width="144" height="28.8" fill="#f00"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'D',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#fc0"/>
+      <rect x="18" y="54" width="144" height="72" fill="#000094"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'E',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#000094"/>
+      <rect x="18" y="90" width="144" height="72" fill="#f00"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'F',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#fff"/>
+      <path d="M 90,18 l 72,72 l -72,72 l -72,-72 z" fill="#f00"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'G',
+      new InlineSvg(
+        `<path fill="#000094" d="m18,18h144v144H18"/>
+      <path stroke="#FC0" stroke-width="24" d="m30,18v144m48,0V18m48,0v144"/>
+      <path d="M18,18H162V162H18z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'H',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#f00"/>
+      <rect x="18" y="18" width="72" height="144" fill="#fff"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'I',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#fc0"/>
+      <circle cx="90" cy="90" r="36" fill="#000"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'J',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#000094"/>
+      <rect x="18" y="66" width="144" height="48" fill="#fff"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'K',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#000094"/>
+      <rect x="18" y="18" width="72" height="144" fill="#fc0"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'L',
+      new InlineSvg(
+        `<rect x="16" y="16" width="148" height="148" rx="2"/>
+      <path fill="#FC0" d="m20,20h70v140h70V90H20"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'M',
+      new InlineSvg(
+        `<clipPath id="c">
+      <path d="M 18,18 H 162 V 162 H 18 z"/>
+      </clipPath>
+      <rect x="18" y="18" width="144" height="144" fill="#000094"/>
+      <path d="M 18,18 L 162,162 M 162,18 L 18,162" clip-path="url(#c)" stroke="#fff" stroke-width="28.8"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'N',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#fff"/>
+      <path d="M 18,18 H 54 V 162 H 90 V 18 H 126 V 162 H 162 V 126 H 18 V 90 H 162 V 54 H 18 z" fill="#000094"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'O',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#fc0"/>
+      <path d="M 18,18 H 162 V 162 z" fill="#f00"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'P',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#000094"/>
+      <rect x="54" y="54" width="72" height="72" fill="#fff"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'Q',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#fc0"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'R',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#f00"/>
+      <path d="M 90,18 V 162 M 18,90 H 162" stroke="#fc0" stroke-width="36"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'S',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#fff"/>
+      <rect x="54" y="54" width="72" height="72" fill="#000094"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'T',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#000094"/>
+      <rect x="18" y="18" width="96" height="144" fill="#fff"/>
+      <rect x="18" y="18" width="48" height="144" fill="#f00"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'U',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#ffffff"/>
+      <path d="M 18,18 H 90 V 90 H 18 z" fill="#ff0000"/>
+      <path d="M 162,91 H 91 V 162 H 162 z" fill="#ff0000"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'V',
+      new InlineSvg(
+        `<clipPath id="c">
+      <path d="M 18,18 H 162 V 162 H 18 z"/>
+      </clipPath>
+      <rect x="18" y="18" width="144" height="144" fill="#fff"/>
+      <path d="M 18,18 L 162,162 M 162,18 L 18,162" clip-path="url(#c)" stroke="#f00" stroke-width="28.8"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'W',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#000094"/>
+      <rect x="42" y="42" width="96" height="96" fill="#fff"/>
+      <rect x="66" y="66" width="48" height="48" fill="#f00"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'X',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#fff"/>
+      <path d="M 90,18 V 162 M 18,90 H 162" stroke="#000094" stroke-width="36"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'Y',
+      new InlineSvg(
+        `<clipPath id="c"><path d="m18,18h144v144H18"/></clipPath>
+      <path fill="#FC0" d="m18,18h144v144H18"/>
+      <path stroke="#F00" stroke-dasharray="18.8" stroke-width="250" clip-path="url(#c)" d="m4,4 160,160"/>
+      <path fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round" d="M18,18H162V162H18z"/>`,
+        180,
+        180
+      )
+    ),
+    new CharacterImage(
+      'Z',
+      new InlineSvg(
+        `<rect x="18" y="18" width="144" height="144" fill="#fc0"/>
+      <path d="M 18,18 V 162 H 162 z" fill="#000"/>
+      <path d="M 162,18 V 162 H 18 z" fill="#000094"/>
+      <path d="M 90,90 L 162,162 H 18 z" fill="#f00"/>
+      <path d="M 18,18 H 162 V 162 H 18 z" fill="none" stroke="#000" stroke-width="3.75" stroke-linejoin="round"/>`,
+        180,
+        180
+      )
+    ),
+    // tslint:enable:max-line-length
+  ];
+
+  get entries(): CharacterImage[] {
+    return this._entries;
+  }
+
+  lookup(letter: string): CharacterImage | null {
+    for (const ch of this._entries) {
+      if (ch.character.toUpperCase() === letter.toUpperCase()) {
+        return ch;
+      }
+    }
+    return null;
+  }
+}

package/src/Resistor/Resistor.ts

@@ -0,0 +1,135 @@
+import {ResistorColorEntry} from './ResistorColorEntry';
+
+export class Resistor {
+  // Name, Color, Multiplier, Value, Tolerance
+  static readonly BLACK = new ResistorColorEntry('Black', '#000000', 1, 0);
+  static readonly BROWN = new ResistorColorEntry('Brown', '#8B4513', 10, 1, 1);
+  static readonly RED = new ResistorColorEntry('Red', '#FF0000', 100, 2, 2);
+  static readonly ORANGE = new ResistorColorEntry('Orange', '#EE7420', 1000, 3);
+  static readonly YELLOW = new ResistorColorEntry(
+    'Yellow',
+    '#FFFF00',
+    10000,
+    4
+  );
+  static readonly GREEN = new ResistorColorEntry(
+    'Green',
+    '#008000',
+    100000,
+    5,
+    0.5
+  );
+  static readonly BLUE = new ResistorColorEntry(
+    'Blue',
+    '#0000FF',
+    1000000,
+    6,
+    0.25
+  );
+  static readonly VIOLET = new ResistorColorEntry(
+    'Violet',
+    '#800080',
+    10000000,
+    7,
+    0.1
+  );
+  static readonly GREY = new ResistorColorEntry(
+    'Grey',
+    '#808080',
+    100000000,
+    8
+  );
+  static readonly WHITE = new ResistorColorEntry(
+    'White',
+    '#FFFFFF',
+    1000000000,
+    9
+  );
+  static readonly GOLD = new ResistorColorEntry(
+    'Gold',
+    '#AB8D3F',
+    0.1,
+    undefined,
+    5
+  );
+  static readonly SILVER = new ResistorColorEntry(
+    'Silver',
+    '#C0C0C0',
+    0.01,
+    undefined,
+    10
+  );
+
+  static readonly colorTable: ResistorColorEntry[] = [
+    Resistor.BLACK,
+    Resistor.BROWN,
+    Resistor.RED,
+    Resistor.ORANGE,
+    Resistor.YELLOW,
+    Resistor.GREEN,
+    Resistor.BLUE,
+    Resistor.VIOLET,
+    Resistor.GREY,
+    Resistor.WHITE,
+    Resistor.GOLD,
+    Resistor.SILVER,
+  ];
+
+  static readonly INVALID_RESISTOR = -1;
+
+  /**
+   * getValue assumes there is no tolerance band, as tolerance is not part of
+   * the value calculation
+   */
+  static getValue(colors: ResistorColorEntry[]) {
+    if (colors.length < 3 || colors.length > 4) {
+      throw new RangeError('Invalid resistor size');
+    }
+
+    // Should we throw an error if the first color is black?  In resistors, it's
+    // technically not allowed, but in puzzle events who knows what they'll do.
+    // The math works out fine (it's just a leading zero), so for now it's
+    // allowed.
+
+    // Iterate through all but the final band (the multipler) and extract the
+    // values
+    let value = 0;
+    for (let i = 0; i < colors.length - 1; ++i) {
+      const currentColor = colors[i];
+      if (currentColor.value === undefined) {
+        return Resistor.INVALID_RESISTOR;
+      }
+
+      value *= 10;
+      value += currentColor.value;
+    }
+
+    return Resistor.applyMultiplier(
+      value,
+      colors[colors.length - 1].multiplier
+    );
+  }
+
+  static getDisplayValue(value: number) {
+    if (value >= 1000000000) {
+      return `${value / 1000000000}G`;
+    } else if (value >= 1000000) {
+      return `${value / 1000000}M`;
+    } else if (value >= 1000) {
+      return `${value / 1000}k`;
+    } else {
+      return value.toString();
+    }
+  }
+
+  private static applyMultiplier(value: number, multipler: number) {
+    if (multipler >= 1) {
+      return value * multipler;
+    } else if (multipler > 0) {
+      // Avoid floating point multiplication issues
+      return value / (1 / multipler);
+    } else {
+      throw new RangeError('Invalid multiplier');
+    }
+  }
+}

package/src/Resistor/ResistorColorEntry.ts

@@ -0,0 +1,43 @@
+export class ResistorColorEntry {
+  readonly name: string;
+  readonly colorCode: string;
+  readonly multiplier: number;
+  readonly value?: number;
+  readonly toleranceInPercent?: number;
+
+  constructor(
+    name: string,
+    colorCode: string,
+    multiplier: number,
+    value?: number,
+    toleranceInPercent?: number
+  ) {
+    this.name = name;
+    this.value = value;
+    this.colorCode = colorCode;
+    this.multiplier = multiplier;
+    this.toleranceInPercent = toleranceInPercent;
+  }
+
+  hasValue() {
+    return this.value !== undefined;
+  }
+
+  getDisplayValue() {
+    if (this.value === undefined) {
+      return '';
+    }
+    return this.value.toString();
+  }
+
+  hasTolerance() {
+    return this.toleranceInPercent !== undefined;
+  }
+
+  getDisplayTolerance() {
+    if (this.toleranceInPercent === undefined) {
+      return '';
+    }
+    return `${this.toleranceInPercent}%`;
+  }
+}

package/src/Semaphore/SemaphoreCharacter.ts

@@ -0,0 +1,107 @@
+import {EncodingCategory} from '../Common/EncodingCategory';
+import {EncodingCharacterBase} from '../Common/EncodingCharacterBase';
+import {EncodingEntry} from '../Common/EncodingEntry';
+
+import {SemaphoreData} from './SemaphoreData';
+import {SemaphoreDegrees} from './SemaphoreDegrees';
+import {SemaphoreDirection} from './SemaphoreDirection';
+import {SemaphoreEncoding} from './SemaphoreEncoding';
+
+export class SemaphoreCharacter extends EncodingCharacterBase<SemaphoreEncoding> {
+  private static parseEncoding(
+    encoding: SemaphoreDirection | SemaphoreEncoding
+  ) {
+    const directions: SemaphoreDirection[] = [];
+
+    for (let i = 1; i <= 8; i++) {
+      const direction = (1 << i) as SemaphoreDirection;
+      if ((encoding & direction) === direction) {
+        directions.push(direction);
+      }
+    }
+
+    return directions;
+  }
+
+  private _directions: SemaphoreDirection[] = [];
+
+  constructor(
+    encoding: SemaphoreEncoding = SemaphoreEncoding.None,
+    category: EncodingCategory = EncodingCategory.All
+  ) {
+    super(SemaphoreData.instance, category);
+
+    this.addDirection(encoding);
+  }
+
+  get directions() {
+    return this._directions;
+  }
+
+  set directions(value: SemaphoreDirection[]) {
+    this._directions = value.slice(0, 2);
+    this.invalidateLookup();
+  }
+
+  addDirection(direction: SemaphoreDirection | SemaphoreEncoding) {
+    for (const dir of SemaphoreCharacter.parseEncoding(direction)) {
+      this._directions.push(dir);
+    }
+
+    if (this._directions.length > 2) {
+      this._directions.splice(0, this._directions.length - 2);
+    }
+
+    this.invalidateLookup();
+  }
+
+  removeDirection(direction: SemaphoreDirection | SemaphoreEncoding) {
+    for (const dir of SemaphoreCharacter.parseEncoding(direction)) {
+      const index = this._directions.indexOf(dir);
+      if (index >= 0) {
+        this._directions.splice(index, 1);
+      }
+    }
+
+    this.invalidateLookup();
+  }
+
+  hasDirection(direction: SemaphoreDirection) {
+    return this._directions.indexOf(direction) >= 0;
+  }
+
+  getDegrees() {
+    return this._directions
+      .map(value => SemaphoreDegrees.ToDegrees(value))
+      .sort((a, b) => a - b);
+  }
+
+  getPotentialMatch(
+    other: SemaphoreDirection
+  ): EncodingEntry<SemaphoreEncoding> | null {
+    if (this.directions.length !== 1 || this.directions[0] === other) {
+      return null;
+    }
+
+    const potentialMatch = this.getPotentialMatches().filter(
+      value => (value.encoding & other) === other
+    )[0];
+
+    return potentialMatch || null;
+  }
+
+  protected onClear() {
+    this._directions.length = 0;
+  }
+
+  protected onEmpty() {
+    return this._directions.length === 0;
+  }
+
+  protected getEncoding() {
+    return this._directions.reduce(
+      (previousValue, currentValue) => (previousValue |= currentValue),
+      SemaphoreEncoding.None
+    );
+  }
+}

package/src/Semaphore/SemaphoreData.ts

@@ -0,0 +1,58 @@
+import {EncodingCategory} from '../Common/EncodingCategory';
+import {EncodingDataBase} from '../Common/EncodingDataBase';
+import {SemaphoreEncoding} from './SemaphoreEncoding';
+
+export class SemaphoreData extends EncodingDataBase<SemaphoreEncoding> {
+  static readonly instance: SemaphoreData = new SemaphoreData();
+
+  constructor() {
+    super();
+
+    // Letters
+    this.addToList(SemaphoreEncoding.LetterA, EncodingCategory.Letter, 'A');
+    this.addToList(SemaphoreEncoding.LetterB, EncodingCategory.Letter, 'B');
+    this.addToList(SemaphoreEncoding.LetterC, EncodingCategory.Letter, 'C');
+    this.addToList(SemaphoreEncoding.LetterD, EncodingCategory.Letter, 'D');
+    this.addToList(SemaphoreEncoding.LetterE, EncodingCategory.Letter, 'E');
+    this.addToList(SemaphoreEncoding.LetterF, EncodingCategory.Letter, 'F');
+    this.addToList(SemaphoreEncoding.LetterG, EncodingCategory.Letter, 'G');
+    this.addToList(SemaphoreEncoding.LetterH, EncodingCategory.Letter, 'H');
+    this.addToList(SemaphoreEncoding.LetterI, EncodingCategory.Letter, 'I');
+    this.addToList(SemaphoreEncoding.LetterJ, EncodingCategory.Letter, 'J');
+    this.addToList(SemaphoreEncoding.LetterK, EncodingCategory.Letter, 'K');
+    this.addToList(SemaphoreEncoding.LetterL, EncodingCategory.Letter, 'L');
+    this.addToList(SemaphoreEncoding.LetterM, EncodingCategory.Letter, 'M');
+    this.addToList(SemaphoreEncoding.LetterN, EncodingCategory.Letter, 'N');
+    this.addToList(SemaphoreEncoding.LetterO, EncodingCategory.Letter, 'O');
+    this.addToList(SemaphoreEncoding.LetterP, EncodingCategory.Letter, 'P');
+    this.addToList(SemaphoreEncoding.LetterQ, EncodingCategory.Letter, 'Q');
+    this.addToList(SemaphoreEncoding.LetterR, EncodingCategory.Letter, 'R');
+    this.addToList(SemaphoreEncoding.LetterS, EncodingCategory.Letter, 'S');
+    this.addToList(SemaphoreEncoding.LetterT, EncodingCategory.Letter, 'T');
+    this.addToList(SemaphoreEncoding.LetterU, EncodingCategory.Letter, 'U');
+    this.addToList(SemaphoreEncoding.LetterV, EncodingCategory.Letter, 'V');
+    this.addToList(SemaphoreEncoding.LetterW, EncodingCategory.Letter, 'W');
+    this.addToList(SemaphoreEncoding.LetterX, EncodingCategory.Letter, 'X');
+    this.addToList(SemaphoreEncoding.LetterY, EncodingCategory.Letter, 'Y');
+    this.addToList(SemaphoreEncoding.LetterZ, EncodingCategory.Letter, 'Z');
+
+    // Numbers
+    this.addToList(SemaphoreEncoding.Number1, EncodingCategory.Number, '1');
+    this.addToList(SemaphoreEncoding.Number2, EncodingCategory.Number, '2');
+    this.addToList(SemaphoreEncoding.Number3, EncodingCategory.Number, '3');
+    this.addToList(SemaphoreEncoding.Number4, EncodingCategory.Number, '4');
+    this.addToList(SemaphoreEncoding.Number5, EncodingCategory.Number, '5');
+    this.addToList(SemaphoreEncoding.Number6, EncodingCategory.Number, '6');
+    this.addToList(SemaphoreEncoding.Number7, EncodingCategory.Number, '7');
+    this.addToList(SemaphoreEncoding.Number8, EncodingCategory.Number, '8');
+    this.addToList(SemaphoreEncoding.Number9, EncodingCategory.Number, '9');
+    this.addToList(SemaphoreEncoding.Number0, EncodingCategory.Number, '0');
+
+    // Formatting
+    this.addToList(
+      SemaphoreEncoding.FormattingNumber,
+      EncodingCategory.Formatting,
+      '#'
+    );
+  }
+}

package/src/Semaphore/SemaphoreDegrees.ts

@@ -0,0 +1,26 @@
+import {SemaphoreDirection} from './SemaphoreDirection';
+
+export class SemaphoreDegrees {
+  static FromDegrees(degrees: number) {
+    if (degrees >= 360) {
+      degrees = degrees % 360;
+    }
+
+    if (degrees % 45 !== 0 || degrees < 0) {
+      throw new Error('Invalid degrees');
+    }
+    const position = degrees / 45;
+    return SemaphoreDirection.North << position;
+  }
+
+  static ToDegrees(direction: SemaphoreDirection) {
+    let position = SemaphoreDirection.North;
+    let counter = 0;
+    while (counter < 9 && position !== direction) {
+      position = position << 1;
+      counter++;
+    }
+
+    return counter * 45;
+  }
+}

package/src/Semaphore/SemaphoreDirection.ts

@@ -0,0 +1,11 @@
+export enum SemaphoreDirection {
+  None = 0,
+  North = 1 << 1,
+  NorthEast = 1 << 2,
+  East = 1 << 3,
+  SouthEast = 1 << 4,
+  South = 1 << 5,
+  SouthWest = 1 << 6,
+  West = 1 << 7,
+  NorthWest = 1 << 8,
+}