TypeScript ekkiog-editing.drawComponent函数代码示例

function replaceComponents(forest : Forest, newComponent : Package){
  const didntFit = [] as {x : number, y : number}[];
  for(const item of getComponents(forest, newComponent.name)){
    if(item.data.package.hash === newComponent.hash) continue;
    const x = item.left + (item.width>>1);
    const y = item.top + (item.height>>1);
    const clearedForest = clear(forest, x, y);
    const newForest = drawComponent(clearedForest, x, y, newComponent);
    if(newForest === clearedForest){
      didntFit.push({x, y});
    }else{
      forest = newForest;
    }
  }
  return {forest, didntFit};
}

function drawItem(forest : Forest, item : Item, x : number, y : number) : Forest {
  switch(item.type){
    case WIRE:
      return drawWire(forest, x, y);
    case UNDERPASS:
      return drawUnderpass(forest, x, y);
    case LIGHT:
      return drawLight(forest, x+1, y+1, item.direction);
    case BUTTON:
      return drawButton(forest, x+1, y+1, item.direction);
    case GATE:
      return drawGate(forest, x+3, y+1);
    case COMPONENT:
      return drawComponent(forest, x+(item.package.width>>1), y+(item.package.height>>1), item.package);
    default:
      return forest;
  }
}

export default function editing(forest=createForest(), action : Action) : Forest{
  switch(action.type){
    case 'set-forest':
      return action.forest || forest;
    case 'draw':
      return tap(forest, action.tool, action.direction, action.x, action.y);
    case 'remove-tile-at':
      return clear(forest, action.x, action.y);
    case 'convert-wire-to-underpass':
      return wireToUnderpass(forest, action.x, action.y);
    case 'convert-underpass-to-wire':
      return underpassToWire(forest, action.x, action.y);
    case 'insert-component':
      return drawComponent(forest, action.position.x+(action.component.width>>1), action.position.y+(action.component.height>>1), action.component);
    default:
      return forest;
  }
}

export default function* zomOutOf({} : ZoomOutOfAction){
  const { context: currentContext, selection: {selection: isSelection}} : State = yield select();

  if(isSelection){
    yield put(stopSelection());
    yield put(resetEditorMenu());
  }

  const outerContext = currentContext.previous;
  if(!outerContext) return;

  const innerContext : ContextState = yield* waitUntilSaved(currentContext);

  yield put(popContext());
  yield put(setUrl(outerContext.repo, outerContext.name));
  if(innerContext.isReadOnly || outerContext.isReadOnly) return;

  const pkg = packageComponent(innerContext.forest, innerContext.repo, innerContext.name, innerContext.hash, innerContext.hash);
  const {forest, didntFit} = replaceComponents(outerContext.forest, pkg);
  if(outerContext.forest !== forest){
    yield put(setForest(forest));
  }

  for(const position of didntFit) {
    yield put(removeTileAt(position.x, position.y));
    const {context: {forest: newForest}} : State = yield select();

    const forest = drawComponent(createForest(newForest.buddyTree), position.x, position.y, pkg);

    const item = getTileAt(forest, position.x, position.y);
    yield* selection(item);
  };

  const { context: newContext } : State = yield select();
  if(outerContext.forest !== newContext.forest){
    yield put(saveForest(`Updated ${pkg.name}`));
  }
}

export default function* insertComponentPackage({componentPackage} : InsertComponentPackageAction){
  const state : State = yield select();

  if(state.selection.selection){
    yield put(stopSelection());
    yield put(resetEditorMenu());
  }

  const tile = state.view.viewportToTile(state.view.pixelWidth/2, state.view.pixelHeight/2);
  const centerTile = {
    x: tile[0]|0,
    y: tile[1]|0
  };

  const forest = drawComponent(createForest(state.context.forest.buddyTree), centerTile.x, centerTile.y, componentPackage);

  const item = getTileAt(forest, centerTile.x, centerTile.y);

  const ok = yield* selection(item);
  if(ok){
    yield put(saveForest(`Inserted ${componentPackage.name}`));
  }
}