TypeScript camelot-unchained.events类代码示例

function registerOtherPatcherHubEvents(dispatch: (action: ControllerAction) => any,
                                        apiHost: string,
                                        controllerState?: ControllerState) {
  if (!window[PATCHER_HUB_WINDOW_ID] || !window[PATCHER_HUB_WINDOW_ID].hubs ||
      !window[PATCHER_HUB_WINDOW_ID].eventListeners) return;

  const characterUpdatedEvent = signalr.getPatcherEventName(apiHost, signalr.PATCHER_EVENTS_CHARACTERUPDATED);
  window[PATCHER_HUB_WINDOW_ID].eventListeners[characterUpdatedEvent] =
    events.on(characterUpdatedEvent, (characterJSON: string) => {
      const character = utils.tryParseJSON<webAPI.SimpleCharacter>(characterJSON, client.debug);
      if (character !== null) {
        if (controllerState && isEqual(controllerState.characters[character.id], character)) {
          // No need to update character if already equal to what we have in state.
          return;
        }

        // Update character
        dispatch(characterUpdate(character));
      }
    });

  const characterRemovedEvent = signalr.getPatcherEventName(apiHost, signalr.PATCHER_EVENTS_CHARACTERREMOVED);
  window[PATCHER_HUB_WINDOW_ID].eventListeners[characterRemovedEvent] =
    events.on(signalr.getPatcherEventName(apiHost, signalr.PATCHER_EVENTS_CHARACTERREMOVED), (id: string) => {
      dispatch(characterRemoved(id));
    });
}

export function setActiveWarbandID(id: string) {
  const stateObjectID = getStateObject().id;
  if (stateObjectID) {
    events.fire('chat-leave-room', stateObjectID);
  }

  if (typeof id === 'string') {
    events.fire('chat-show-room', id, 'Warband');
  }
  getStateObject().id = id;
  getStateObject().membersMap = {};
  getStateObject().membersEntityIDMap = {};
}

// HELPER METHODS
function registerPatcherHubEvents(dispatch: (action: ControllerAction) => any) {
  events.on(signalr.PATCHER_EVENTS_ALERT, (alertJSON: string) => {
    const alert = utils.tryParseJSON<webAPI.PatcherAlert>(alertJSON, client.debug);
    if (alert !== null) dispatch(alertReceived(alert));
  });

  events.on(signalr.PATCHER_EVENTS_SERVERUPDATED, (serverJSON: string) => {
    const server = utils.tryParseJSON<webAPI.ServerModel>(serverJSON, client.debug);
    if (server !== null) dispatch(serverUpdate(server));
  });

  events.on(signalr.PATCHER_EVENTS_SERVERUNAVAILABLE, (name: string) => dispatch(serverUnavailable(name)));
}

export function initialize(dispatch: any) {

  events.addListener(events.buildingEventTopics.handlesBlocks, (info: { materials: BuildingMaterial[] }) => {
    const matsByType: MaterialsByType = new MaterialsByType(info.materials);
    dispatch(setMaterialsByType(matsByType));
  });

  events.addListener(DEACTIVATE_MATERIAL_SELECTOR, (info: {}) => {
    // dispatch(updateMaterialSelector(null, null));
  });

  events.addListener(ACTIVATE_MATERIAL_SELECTOR,
                     (info: { selection: BuildingMaterial, onSelect: (material: BuildingMaterial) => void }) => {
                       dispatch(updateMaterialSelector(info.selection, info.onSelect));
                     });
}

  return (dispatch: (action: any) => any) => {
    dispatch(init());
    window.onresize = () => {
      if (window.innerWidth >= 640 && window.innerHeight >= 480) {
        dispatch(resize());
      }
    };

    // hook up to event triggers
    events.on('hudnav--navigate', (name: string) => {
      switch (name) {
        case 'chat':
          return dispatch(toggleVisibility(name));
        case 'ui': return dispatch(toggleHUDLock(addEvent, removeEvent));
        case 'lockui': return dispatch(lockHUD(removeEvent));
        case 'reset': return dispatch(resetHUD());
        default: return;
      }
    });

    const listener = (e: KeyboardEvent) => {
      if (e.which === 27) {
        dispatch(lockHUD(removeEvent));
      }
    };
    const addEvent = () => window.window.addEventListener('keydown', listener);
    const removeEvent = () => window.window.removeEventListener('keydown', listener);
  };

export function initializeBuilding(dispatch: any) {

  requester.loadMaterials();

  events.addListener(events.buildingEventTopics.handlesBuildingMode, (info: { mode: buildUIMode }) => {
    dispatch(setMode(info.mode));
  });
}

function unregisterOtherPatcherHubEvents(apiHost: string) {
  if (
    !window[PATCHER_HUB_WINDOW_ID] ||
    !window[PATCHER_HUB_WINDOW_ID].hubs ||
    !window[PATCHER_HUB_WINDOW_ID].eventListeners
  ) {
    return;
  }

  const characterUpdatedEvent = signalr.getPatcherEventName(apiHost, signalr.PATCHER_EVENTS_CHARACTERUPDATED);
  events.off(window[PATCHER_HUB_WINDOW_ID].eventListeners[characterUpdatedEvent]);
  window[PATCHER_HUB_WINDOW_ID].hubs.eventListeners[characterUpdatedEvent] = null;

  const characterRemovedEvent = signalr.getPatcherEventName(apiHost, signalr.PATCHER_EVENTS_CHARACTERREMOVED);
  events.off(window[PATCHER_HUB_WINDOW_ID].eventListeners[characterRemovedEvent]);
  window[PATCHER_HUB_WINDOW_ID].hubs.eventListeners[characterRemovedEvent] = null;
}

export function initialize(dispatch: (action: any) => void) {

  events.addListener(events.buildingEventTopics.handlesBlocks, (info: { materials: BuildingMaterial[] }) => {
    const mats: BuildingMaterial[] = info.materials;
    dispatch(setMaterials(mats));
    dispatch(selectFromMaterial(mats[0]));
    dispatch(selectToMaterial(mats[0]));
  });

  events.addListener(
    events.buildingEventTopics.handlesBlockSelect, (info: { material: BuildingMaterial, block: BuildingBlock }) => {
      dispatch(selectBlock(info.block));
      dispatch(selectFromMaterial(info.material));
    });

  events.addListener(events.buildingEventTopics.handlesBuildingMode, (info: { mode: buildUIMode }) => {
    dispatch(setBlockMode(info.mode === buildUIMode.BLOCKSELECTED));
  });

}

export function loadBlueprints(dispatch: (action: any) => void) {

  events.addListener(events.buildingEventTopics.handlesBlueprints, (info: { blueprints: BuildingBlueprint[] }) => {
    dispatch(updateBlueprints(info.blueprints));
  });

  events.addListener(events.buildingEventTopics.handlesBlueprintSelect, (info: { blueprint: BuildingBlueprint }) => {
    dispatch(selectBlueprint(info.blueprint));
  });

  events.addListener(events.buildingEventTopics.handlesBuildingMode, (info: { mode: buildUIMode }) => {
    dispatch(copyModeChanged(info.mode === buildUIMode.BLOCKSELECTED));
  });

  events.addListener(events.buildingEventTopics.handlesBlueprintCopy, () => {
    dispatch(pasteModeChanged(true));
  });

  requester.requestBlueprints();
}

export function showCompassTooltip(tooltip: CompassTooltipData) {
  events.fire('compass-tooltip--show', tooltip);
}