TypeScript camelot-unchained.utils类代码示例

actionDefs[ALERT_RECIEVED] = function alertRecievedReducer(state: ControllerState, action: ControllerAction): ControllerState {
  const alerts = utils.clone(state.alerts);
  alerts[action.alert.id] = action.alert;
  return utils.merge(state, {
    alerts: alerts
  });
};

actionDefs[ALERT_EXPIRED] = function alertExpiredReducer(state: ControllerState, action: ControllerAction): ControllerState {
  const alerts = utils.clone(state.alerts);
  delete alerts[action.id];
  return utils.merge(state, {
    alerts: alerts
  });
}

actionDefs[SERVER_UNAVAILABLE] = function serverUnavailableReducer(state: ControllerState, action: ControllerAction): ControllerState {
  const servers = utils.clone(state.servers);
  servers[action.id].available = false;
  return utils.merge(state, {
    servers: servers
  });
}

  reducer: (s, a) => {
    const channelServers: utils.Dictionary<PatcherServer> = {};
    const channelDict: utils.Dictionary<Channel> = {};
    for (let i = 0; i < a.channels.length; ++i) {
      const c = a.channels[i];
      // check if we have a server with a matching name to a channel, if not the channel becomes it's own 'server'.
      if (!s.servers[c.channelName]) {
        // create a server for this channel
        channelServers[c.channelName] = channelToPatcherServer(c);
      } else {
        // if it's not it's own server add to a dictionary to update servers by channel id
        channelDict[c.channelID] = c;

        // while we're here lets see if we need to update the last updated time
        if (s.servers[c.channelName].channelStatus === ChannelStatus.Updating && c.channelStatus === ChannelStatus.Ready) {
          localStorage.setItem(`channel_updated_${c.channelName}`, a.when.toLocaleString());
        }
      }
    }

    const servers = utils.clone(s.servers);
    for (const key in servers) {
      const server = servers[key];
      servers[key].channelStatus = channelDict[server.channelID] ? channelDict[server.channelID].channelStatus :
        ChannelStatus.NotInstalled;
      servers[key].lastUpdated = channelDict[server.channelID].lastUpdated || 0;
    }

    return {
      servers: utils.merge(servers, channelServers),
    };
  },

 reducer: (s, a) => {
   if (a.server.name === 'localhost') return {};
   const servers = utils.clone(s.servers);
   servers[a.server.name] = utils.merge(servers[a.server.name], webAPIServerToPatcherServer(a.server));
   return {
     servers,
   };
 },

actionDefs[SERVER_UPDATE] = function serverUpdateReducer(state: ControllerState, action: ControllerAction): ControllerState {
  if (action.server.name === 'localhost') return state;
  const servers = utils.clone(state.servers);
  servers[action.server.name] = utils.merge(servers[action.server.name], webAPIServerToPatcherServer(action.server));
  return utils.merge(state, {
    servers: servers
  });
}

actionDefs[CHARACTER_UPDATE] = function characterUpdateReducer(state: ControllerState, action: ControllerAction): ControllerState {
  const characters = utils.clone(state.characters);
  characters[action.character.id] = action.character;
  const servers = updateCharacterCounts(utils.clone(state.servers), characters);
  return utils.merge(state, {
    characters: characters,
    servers: servers
  });
}

actionDefs[CHARACTER_REMOVED] = function characterRemovedReducer(state: ControllerState, action: ControllerAction): ControllerState {
  const characters = utils.clone(state.characters);
  delete characters[action.id];
  const servers = updateCharacterCounts(utils.clone(state.servers), characters);
  return utils.merge(state, {
    characters: characters,
    servers: servers
  });
}

 reducer: (s, a) => {
   const characters = utils.clone(s.characters);
   delete characters[a.id];
   const servers = updateCharacterCounts(utils.clone(s.servers), characters);
   return {
     characters,
     servers,
   };
 },

function webAPIServerToPatcherServer(server: webAPI.servers.Server): PatcherServer {

  const channels = patcher.getAllChannels();
  const channelIndex = utils.findIndexWhere(channels, c => c.channelID === server.channelID);
  const channel = channels[channelIndex];

  return utils.merge({
    name: server.name,
    available: server.playerMaximum > 0,
    type: ServerType.CUGAME,
    channelStatus: channel ? channel.channelStatus : ChannelStatus.NotInstalled,
  }, server);
}