四月八日

// 投币
// 点击出货

abstract class State {
  machine: VendingMachine;
  constructor(machine: VendingMachine) {
    this.machine = machine;
  }
  addCoin(coin?: Number) {
    console.log("必须实现 addCoin");
  }
  getProduct() {
    console.log("必须实现 getProduct");
  }
}

// 无商品

class NoProduct extends State {
  addCoin() {
    console.log("机器里无商品，你不能购买");
  }
  getProduct() {
    console.log("机器里无商品，你不能购买");
  }
}

class HasProduct extends State {
  addCoin(coin: number) {
    this.machine.coin += coin;
  }
  getProduct() {
    console.log("你已经获取了商品");
    this.machine.count -= 1;
    this.machine.coin -= 1;
    this.stateTransform();
  }
  stateTransform() {
    const { count, coin } = this.machine;
    if (coin === 0) {
      this.machine.setState(this.machine.stateNoCoin);
    } else if (count === 0) {
      this.machine.setState(this.machine.stateNoProduct);
    }
  }
}

class NoCoin extends State {}

class VendingMachine {
  stateNoProduct: NoProduct;
  stateHasProduct: HasProduct;
  stateNoCoin: NoCoin;
  count: number;
  coin: number = 0;
  state: NoProduct | HasProduct;
  constructor(count: number) {
    this.count = count || 2;
    this.stateNoProduct = new NoProduct(this);
    this.stateHasProduct = new HasProduct(this);
    this.stateNoCoin = new NoCoin(this);
    this.state = this.stateHasProduct;
  }
  setState(state: NoProduct | HasProduct) {
    this.state = state;
  }
  addCoin(coin = 0) {
    this.state.addCoin(coin);
  }
  getProduct() {
    this.state.getProduct();
  }
}

const queue = [];
const draw = () => {
  requestAnimationFrame(() => {
    let len = queue.length;
    for (var i = 0; i < len; i++) {
      const a = queue[i];
      ctx.lineTo(a[0], a[1]);
    }
    if (len) {
      ctx.stroke();
    }
    queue = [];
    if (mark) draw();
  });
};

canvas?.addEventListener("pointerdown", () => {
  mark = true;
  // 取整数减少浮点运算
  queue.push([
    Math.floor(e.clientX * window.devicePixelRatio),
    Math.floor(e.clientY * window.devicePixelRatio),
  ]);
  ctx.beginPath();
  draw();
});

let queue: any[] = [];
const offScreen = new OffscreenCanvas(dimension.width, dimension.height);
const offCtx = offScreen.getContext("2d") as OffscreenCanvasRenderingContext2D;
offCtx.scale(width / dimension.width, height / dimension.height);
offCtx.strokeStyle = "red";
offCtx.lineWidth = 6;
offCtx.lineCap = "round";

const draw = () => {
  requestAnimationFrame(() => {
    let len = queue.length;
    offCtx.clearRect(0, 0, dimension.width, dimension.height);
    // 在清除画布之后必须使用 beginPath
    offCtx.beginPath();
    for (var i = 0; i < len; i++) {
      const a = queue[i];
      offCtx.lineTo(a[0], a[1]);
    }
    if (len) {
      offCtx.stroke();
    }

    for (let i = 1; i < len; i++) {
      const pre = queue[i - 1];
      const cur = queue[i];
      const length = Math.round(
        Math.sqrt(Math.pow(pre[0] - cur[0], 2) + Math.pow(pre[1] - cur[1], 2))
      );
      const xUnit = (cur[0] - pre[0]) / length;
      const yUnit = (cur[1] - pre[1]) / length;
      for (let i = 0; i < length; i++) {
        const xCurrent = pre[0] + i * xUnit;
        const yCurrent = pre[1] + i * yUnit;
        const xRandom = xCurrent + (Math.random() - 0.5) * 6 * 1.2;
        const yRandom = yCurrent + (Math.random() - 0.5) * 6 * 1.2;
        offCtx.clearRect(
          xRandom,
          yRandom,
          Math.random() * 2 + 2,
          Math.random() + 1
        );
      }
    }

    queue = [];

    ctx.globalCompositeOperation = "source-over";
    ctx.drawImage(offScreen, 0, 0, dimension.width, dimension.height);
    if (mark) draw();
  });
};

class Test1 {
  data = ["a1", "b1", "c1"];
}

class Test2 {
  data = {
    a2: "a2",
    b2: "b2",
    c2: "c2",
  };
}

interface IteratorClass<T> {
  new (): T;
}
interface IIterator {
  iterator(): IterableIterator<string>;
}

// 遵循面向接口编程的原则，两个类都实现了相同的接口

class Test1 implements IIterator {
  data = ["a1", "b1", "c1"];
  iterator() {
    return this.data[Symbol.iterator]();
  }
}

class Test2 implements IIterator {
  data = {
    a2: "a2",
    b2: "b2",
    c2: "c2",
  };
  iterator() {
    const iterator = (): IterableIterator<string> => {
      let data = this.data;
      let keys = Object.keys(data);
      let index = 0;
      return {
        next() {
          return index < keys.length
            ? {
                value: data[keys[index++] as keyof typeof data],
                done: false,
              }
            : {
                value: undefined,
                done: true,
              };
        },
      } as IterableIterator<string>;
    };

    return iterator();
  }
}

class MapObject {
  test1: Test1;
  test2: Test2;
  constructor(test1: IteratorClass<Test1>, test2: IteratorClass<Test2>) {
    this.test1 = new test1();
    this.test2 = new test2();
  }
  printItem() {
    let stack = [this.test1, this.test2];

    stack.forEach((instance) => {
      let iterator = instance.iterator();
      let done: any, value: any;
      do {
        ({ done, value } = iterator.next());
        if (value) {
          console.log(value);
        }
      } while (!done);
    });
  }
}

abstract class AbstractDataCollection {
  abstract createIterator(): any;
  print(): void {
    let done: any, value: any;
    const iterator = this.createIterator();
    do {
      ({ done, value } = iterator.next());
      if (!done) {
        value.print();
      }
    } while (!done);
  }
}

class DataCollection1 extends AbstractDataCollection {
  data: any[] = [];
  add(dataItem: any) {
    this.data.push(dataItem);
    return this;
  }
  iterator() {
    return this.data[Symbol.iterator]();
  }
  createIterator() {
    return new CompositeIterator(this.iterator());
  }
}
class DataCollection2 extends AbstractDataCollection {
  data: { [key: string]: any } = {};
  add(dataItem: any, key: string) {
    this.data[key] = dataItem;
    return this;
  }
  iterator() {
    let data = this.data;
    let keys = Object.keys(data);
    let index = 0;
    return {
      next() {
        return index < keys.length
          ? {
              value: data[keys[index++] as keyof typeof data],
              done: false,
            }
          : {
              value: undefined,
              done: true,
            };
      },
    };
  }
  createIterator() {
    return new CompositeIterator(this.iterator());
  }
}

type LinkData = {
  next: LinkData | null;
  value?: any;
};

class DataCollection3 extends AbstractDataCollection {
  data: LinkData = { next: null };
  last: LinkData = this.data;
  add(dataItem: any) {
    this.last.next = {
      value: dataItem,
      next: null,
    };
    this.last = this.last.next;
    return this;
  }
  iterator() {
    let data: LinkData | null = this.data;
    return {
      next() {
        data = data!.next;

        if (data === null) {
          return {
            done: true,
            value: undefined,
          };
        } else {
          return {
            done: false,
            value: data.value,
          };
        }
      },
    };
  }
  createIterator() {
    return new CompositeIterator(this.iterator());
  }
}

class DataItem extends AbstractDataCollection {
  data: any;
  constructor(data: any) {
    super();
    this.data = data;
  }
  createIterator() {
    return new NullIterator();
  }
  print(): void {
    console.log(this.data);
  }
}

class CompositeIterator<T> implements Iterator<T> {
  stack: Iterator<T>[] = [];
  constructor(iterator: Iterator<T>) {
    this.stack.push(iterator);
  }
  next(...args: [] | [undefined]): IteratorResult<T, any> {
    if (this.stack.length) {
      const iterator = this.stack.pop();

      let component = iterator!.next();
      if (!component.done) {
        this.stack.push(iterator!);
      }
      return component;
    } else {
      return {
        value: undefined,
        done: true,
      };
    }
  }
}

class NullIterator<T> implements Iterator<T> {
  next(...args: [] | [undefined]): IteratorResult<T, any> {
    return {
      done: true,
      value: undefined,
    };
  }
}

const t = new DataCollection1();
t.add(new DataItem(1));
t.add(new DataItem(2));

const p = new DataCollection2();

p.add(new DataItem("a"), "a");
p.add(new DataItem("b"), "b");

const q = new DataCollection3();
q.add(new DataItem("p"));

const w = new DataCollection2();
w.add(new DataItem("w1"), "w1");
w.add(new DataItem("w2"), "w2");

q.add(w);

q.add(new DataItem("q"));

class MapObject extends AbstractDataCollection {
  stack: any[] = [];
  add(instance: AbstractDataCollection) {
    this.stack.push(instance);
    return this;
  }
  iterator() {
    return this.stack[Symbol.iterator]();
  }
  createIterator() {
    return new CompositeIterator(this.iterator());
  }
}
const o = new MapObject();

o.add(t);
o.add(p);
o.add(q);
o.print();

abstract class MakeNoodles {
  public addWater() {}
  // 加入某种类型的面
  public addNoodle(noodleType: string) {
    console.log("加入" + noodleType);
  }
  // 等一分钟加入调料
  public waitMinuteAddCondiment(condiment: string) {
    console.log("一分钟后加入" + condiment);
  }
  // 装盘
  public sabot() {}
}

// 挂面
class MakeFineDriedNoodles extends MakeNoodles {
  addNoodle(type: string) {
    super.addNoodle(type);
  }
  waitMinuteAddCondiment(condiment: string) {
    super.waitMinuteAddCondiment(condiment);
  }
}

type MakeNoodlesType = {
  new (): any;
};
// 挂面
class MakeFineDriedNoodles {
  makeNoodles: MakeNoodles;
  constructor(MakeNoodlesConstructor: MakeNoodlesType) {
    this.makeNoodles = new MakeNoodlesConstructor();
  }
  addNoodle(type: string) {
    this.makeNoodles.addNoodle(type);
  }
  waitMinuteAddCondiment(condiment: string) {
    this.makeNoodles.waitMinuteAddCondiment(condiment);
  }
}

abstract class MakeNoodles {
  // 等一分钟加入调料
  public waitMinuteAddCondiment(condiment: string) {
    if (this.likeCondiment()) {
      console.log("一分钟后加入" + condiment);
    }
  }
  public likeCondiment() {
    return true;
  }
}

// 挂面
class MakeFineDriedNoodles extends MakeNoodles {
  likeCondiment() {
    return false;
  }
  waitMinuteAddCondiment(condiment: string) {
    super.waitMinuteAddCondiment(condiment);
  }
}

class MakeNoodles {
  // 等一分钟加入调料
  public waitMinuteAddCondiment(condiment: string) {
    if (this.likeCondiment()) {
      console.log("一分钟后加入" + condiment);
    }
  }
  public likeCondiment() {
    return true;
  }
}
type MakeNoodlesType = {
  new (): any;
};
// 挂面
class MakeFineDriedNoodles {
  makeNoodles: MakeNoodles;
  constructor(MakeNoodlesConstructor: MakeNoodlesType) {
    this.makeNoodles = new MakeNoodlesConstructor();
  }
  likeCondiment() {
    return false;
  }
  waitMinuteAddCondiment(condiment: string) {
    this.makeNoodles.likeCondiment = this.likeCondiment;
    this.makeNoodles.waitMinuteAddCondiment(condiment);
  }
}