habitica/website/common/script/ops/scoreTask.js

import find from 'lodash/find';
import timesLodash from 'lodash/times';
import reduce from 'lodash/reduce';
import moment from 'moment';
import max from 'lodash/max';
import {
  BadRequest,
  NotAuthorized,
} from '../libs/errors';
import i18n from '../i18n';
import updateStats from '../fns/updateStats';
import crit from '../fns/crit';
import getUtcOffset from '../fns/getUtcOffset';

import statsComputed from '../libs/statsComputed';
import { checkOnboardingStatus } from '../libs/onboarding';

const MAX_TASK_VALUE = 21.27;
const MIN_TASK_VALUE = -47.27;
const CLOSE_ENOUGH = 0.00001;

function _getTaskValue (taskValue) {
  if (taskValue < MIN_TASK_VALUE) {
    return MIN_TASK_VALUE;
  } if (taskValue > MAX_TASK_VALUE) {
    return MAX_TASK_VALUE;
  }
  return taskValue;
}

// Calculates the next task.value based on direction
// Uses a capped inverse log y=.95^x, y>= -5
function _calculateDelta (task, direction, cron) {
  // Min/max on task redness
  const currVal = _getTaskValue(task.value);
  let nextDelta = (0.9747 ** currVal) * (direction === 'down' ? -1 : 1);

  // Checklists
  if (task.checklist && task.checklist.length > 0) {
    // If the Daily, only dock them a portion based on their checklist completion
    if (direction === 'down' && task.type === 'daily' && cron) {
      nextDelta *= 1 - reduce(
        task.checklist,
        (m, i) => m + (i.completed ? 1 : 0),
        0,
      ) / task.checklist.length;
    }

    // If To Do, point-match the TD per checklist item completed
    if (task.type === 'todo' && !cron) {
      nextDelta *= 1 + reduce(task.checklist, (m, i) => m + (i.completed ? 1 : 0), 0);
    }
  }

  return nextDelta;
}

// Approximates the reverse delta for the task value
// This is meant to return the task value to its original value when unchecking a task.
// First, calculate the value using the normal way for our first guess although
// it will be a bit off
function _calculateReverseDelta (task, direction) {
  const currVal = _getTaskValue(task.value);
  let testVal = currVal + (0.9747 ** currVal) * (direction === 'down' ? -1 : 1);

  // Now keep moving closer to the original value until we get "close enough"
  // Check how close we are to the original value by computing the delta off our guess
  // and looking at the difference between that and our current value.
  while (true) { // eslint-disable-line no-constant-condition
    const calc = testVal + (0.9747 ** testVal);
    const diff = currVal - calc;

    if (Math.abs(diff) < CLOSE_ENOUGH) break;

    if (diff > 0) {
      testVal -= diff;
    } else {
      testVal += diff;
    }
  }

  // When we get close enough, return the difference between our approximated value
  // and the current value.  This will be the delta calculated from the original value
  // before the task was checked.
  let nextDelta = testVal - currVal;

  // Checklists - If To Do, point-match the TD per checklist item completed
  if (task.checklist && task.checklist.length > 0 && task.type === 'todo') {
    nextDelta *= 1 + reduce(task.checklist, (m, i) => m + (i.completed ? 1 : 0), 0);
  }

  return nextDelta;
}

function _gainMP (user, val) {
  val *= user._tmp.crit || 1; // eslint-disable-line no-param-reassign
  user.stats.mp += val;

  if (user.stats.mp >= statsComputed(user).maxMP) user.stats.mp = statsComputed(user).maxMP;
  if (user.stats.mp < 0) {
    user.stats.mp = 0;
  }
}

// HP modifier
// ===== CONSTITUTION =====
// TODO Decreases HP loss from bad habits / missed dailies by 0.5% per point.
function _subtractPoints (user, task, stats, delta) {
  if (task.group.id && task.type === 'daily') return stats.hp;
  let conBonus = 1 - statsComputed(user).con / 250;
  if (conBonus < 0.1) conBonus = 0.1;

  const hpMod = delta * conBonus * task.priority * 2; // constant 2 multiplier for better results
  stats.hp += Math.round(hpMod * 10) / 10; // round to 1dp
  return stats.hp;
}

function _addPoints (user, task, stats, direction, delta) {
  const _crit = user._tmp.crit || 1;

  // Exp Modifier
  // ===== Intelligence =====
  // TODO Increases Experience gain by .2% per point.
  const intBonus = 1 + statsComputed(user).int * 0.025;
  stats.exp += Math.round(delta * intBonus * task.priority * _crit * 6);

  // GP modifier
  // ===== PERCEPTION =====
  // TODO Increases Gold gained from tasks by .3% per point.
  const perBonus = 1 + statsComputed(user).per * 0.02;
  const gpMod = delta * task.priority * _crit * perBonus;

  if (task.streak) {
    const currStreak = direction === 'down' ? task.streak - 1 : task.streak;
    const streakBonus = currStreak / 100 + 1; // eg, 1-day streak is 1.01, 2-day is 1.02, etc
    const afterStreak = gpMod * streakBonus;
    if (currStreak > 0 && gpMod > 0) {
      // keep this on-hand for later, so we can notify streak-bonus
      user._tmp.streakBonus = afterStreak - gpMod;
    }

    stats.gp += afterStreak;
  } else {
    stats.gp += gpMod;
  }
}

function _changeTaskValue (user, task, direction, times, cron) {
  let addToDelta = 0;

  // ===== CRITICAL HITS =====
  // allow critical hit only when checking off a task, not when unchecking it:
  const _crit = direction === 'up' ? crit.crit(user) : 1;
  // if there was a crit, alert the user via notification
  if (_crit > 1) user._tmp.crit = _crit;

  // If multiple days have passed, multiply times days missed
  timesLodash(times, () => {
    // Each iteration calculate the nextDelta, which is then accumulated in the total delta.
    const nextDelta = !cron && direction === 'down' ? _calculateReverseDelta(task, direction) : _calculateDelta(task, direction, cron);

    if (task.type !== 'reward') {
      if (user.preferences.automaticAllocation === true && user.preferences.allocationMode === 'taskbased' && !(task.type === 'todo' && direction === 'down')) {
        user.stats.training[task.attribute] += nextDelta;
      }

      if (direction === 'up') { // Make progress on quest based on STR
        user.party.quest.progress.up = user.party.quest.progress.up || 0;
        const prevProgress = user.party.quest.progress.up;

        if (task.type === 'todo' || task.type === 'daily') {
          user.party.quest.progress.up += nextDelta * _crit * (1 + statsComputed(user).str / 200);
        } else if (task.type === 'habit') {
          user.party.quest.progress.up += nextDelta * _crit * (0.5 + statsComputed(user).str / 400);
        }

        if (!user._tmp.quest) user._tmp.quest = {};
        user._tmp.quest.progressDelta = user.party.quest.progress.up - prevProgress;
      }
      task.value += nextDelta;
    }

    addToDelta += nextDelta;
  });

  return addToDelta;
}

function _updateCounter (task, direction, times) {
  if (direction === 'up') {
    task.counterUp += times;
  } else {
    task.counterDown += times;
  }
}

function _lastHistoryEntryWasToday (lastHistoryEntry, user) {
  if (!lastHistoryEntry || !lastHistoryEntry.date) {
    return false;
  }

  const timezoneUtcOffset = getUtcOffset(user);
  const { dayStart } = user.preferences;

  // Adjust the last entry date according to the user's timezone and CDS
  const dateWithTimeZone = moment(lastHistoryEntry.date).utcOffset(timezoneUtcOffset);
  if (dateWithTimeZone.hour() < dayStart) dateWithTimeZone.subtract(1, 'day');

  return moment().utcOffset(timezoneUtcOffset).isSame(dateWithTimeZone, 'day');
}

function _updateLastHistoryEntry (lastHistoryEntry, task, direction, times) {
  lastHistoryEntry.value = task.value;
  lastHistoryEntry.date = Number(new Date());

  // @TODO remove this extra check after migration
  // has run to set scoredUp and scoredDown in every task
  lastHistoryEntry.scoredUp = lastHistoryEntry.scoredUp || 0;
  lastHistoryEntry.scoredDown = lastHistoryEntry.scoredDown || 0;

  if (direction === 'up') {
    lastHistoryEntry.scoredUp += times;
  } else {
    lastHistoryEntry.scoredDown += times;
  }
}

export default function scoreTask (options = {}, req = {}, analytics) {
  const {
    user, task, direction, times = 1, cron = false,
  } = options;
  let delta = 0;
  const stats = {
    gp: user.stats.gp,
    hp: user.stats.hp,
    exp: user.stats.exp,
  };

  // This is for setting one-time temporary flags,
  // such as streakBonus or itemDropped. Useful for notifying
  // the API consumer, then cleared afterwards
  // Keep user._tmp.leveledUp if it already exists
  // To make sure infos on level ups don't get lost when bulk scoring multiple tasks
  const oldLeveledUp = user._tmp && user._tmp.leveledUp;
  user._tmp = {};

  if (oldLeveledUp) user._tmp.leveledUp = oldLeveledUp;

  // Thanks to open group tasks, userId is not guaranteed. Don't allow scoring inaccessible tasks
  if (task.userId && task.userId !== user._id) {
    throw new BadRequest('Cannot score task belonging to another user.');
  } else if (task.group && task.group.id && user.guilds.indexOf(task.group.id) === -1
    && user.party._id !== task.group.id) {
    throw new BadRequest('Cannot score task belonging to another user.');
  }
  // If they're trying to purchase a too-expensive reward, don't allow them to do that.
  if (task.value > user.stats.gp && task.type === 'reward') throw new NotAuthorized(i18n.t('messageNotEnoughGold', req.language));

  if (task.type === 'habit') {
    delta += _changeTaskValue(user, task, direction, times, cron);

    // Add habit value to habit-history (if different)
    if (delta > 0) {
      _addPoints(user, task, stats, direction, delta);
    } else {
      _subtractPoints(user, task, stats, delta);
    }
    _gainMP(user, max([0.25, 0.0025 * statsComputed(user).maxMP]) * (direction === 'down' ? -1 : 1));

    // Save history entry for habit
    task.history = task.history || [];
    const historyLength = task.history.length;
    const lastHistoryEntry = task.history[historyLength - 1];

    if (_lastHistoryEntryWasToday(lastHistoryEntry, user)) {
      _updateLastHistoryEntry(lastHistoryEntry, task, direction, times);
      if (task.markModified) {
        task.markModified(`history.${historyLength - 1}`);
      }
    } else {
      task.history.push({
        date: Number(new Date()),
        value: task.value,
        scoredUp: direction === 'up' ? 1 : 0,
        scoredDown: direction === 'down' ? 1 : 0,
      });
    }

    _updateCounter(task, direction, times);
  } else if (task.type === 'daily') {
    if (cron) {
      delta += _changeTaskValue(user, task, direction, times, cron);
      _subtractPoints(user, task, stats, delta);
      // Chilling frost should not affect challenge or group dailies
      if (!user.stats.buffs.streaks || task.challenge.id || task.group.id) task.streak = 0;
    } else {
      delta += _changeTaskValue(user, task, direction, times, cron);
      if (direction === 'down') delta = _calculateDelta(task, direction, cron); // recalculate delta for unchecking so the gp and exp come out correctly
      // obviously for delta>0, but also a trick to undo accidental checkboxes
      _addPoints(user, task, stats, direction, delta);
      _gainMP(user, max([1, 0.01 * statsComputed(user).maxMP]) * (direction === 'down' ? -1 : 1));

      if (direction === 'up') {
        if (task.group.id) {
          if (!task.group.assignedUsers || task.group.assignedUsers.length === 0) {
            task.group.completedBy = {
              userId: user._id,
              date: new Date(),
            };
            task.completed = true;
            task.streak += 1;
          } else {
            task.group.assignedUsersDetail[user._id].completed = true;
            task.group.assignedUsersDetail[user._id].completedDate = new Date();
            if (!find(task.group.assignedUsersDetail, assignedUser => !assignedUser.completed)) {
              task.dateCompleted = new Date();
              task.completed = true;
              task.streak += 1;
            }
          }
          if (task.markModified) task.markModified('group');
        } else {
          task.streak += 1;
          // Give a streak achievement when the streak is a multiple of 21
          if (task.streak !== 0 && task.streak % 21 === 0) {
            user.achievements.streak = user.achievements.streak ? user.achievements.streak + 1 : 1;
            if (user.addNotification) user.addNotification('STREAK_ACHIEVEMENT');
          }
          task.completed = true;

          // Save history entry for daily
          task.history = task.history || [];
          const historyEntry = {
            date: Number(new Date()),
            value: task.value,
            isDue: task.isDue,
            completed: true,
          };
          task.history.push(historyEntry);
        }
      } else if (direction === 'down') {
        if (task.group.id) {
          if (!task.group.assignedUsersDetail
            || !find(task.group.assignedUsersDetail, assignedUser => !assignedUser.completed)
          ) {
            task.streak -= 1;
            task.completed = false;
          }
          if (task.group.completedBy) task.group.completedBy = {};
          if (task.group.assignedUsersDetail && task.group.assignedUsersDetail[user._id]) {
            task.group.assignedUsersDetail[user._id].completed = false;
            task.group.assignedUsersDetail[user._id].completedDate = undefined;
          }
          if (task.markModified) task.markModified('group');
        } else {
          // Remove a streak achievement if streak was a multiple of 21 and the daily was undone
          if (task.streak !== 0 && task.streak % 21 === 0) {
            user.achievements.streak = user.achievements.streak ? user.achievements.streak - 1 : 0;
          }
          task.streak -= 1;
          task.completed = false;

          // Delete history entry when daily unchecked
          if (task.history || task.history.length > 0) {
            task.history.splice(-1, 1);
          }
        }
      }
    }
  } else if (task.type === 'todo') {
    if (cron) { // don't touch stats on cron
      delta += _changeTaskValue(user, task, direction, times, cron);
    } else {
      if (direction === 'up') {
        if (task.group.id) {
          if (!task.group.assignedUsers || task.group.assignedUsers.length === 0) {
            task.group.completedBy = {
              userId: user._id,
              date: new Date(),
            };
            task.completed = true;
          } else {
            task.group.assignedUsersDetail[user._id].completed = true;
            task.group.assignedUsersDetail[user._id].completedDate = new Date();
            if (!find(task.group.assignedUsersDetail, assignedUser => !assignedUser.completed)) {
              task.dateCompleted = new Date();
              task.completed = true;
            }
          }
          if (task.markModified) task.markModified('group');
        } else {
          task.dateCompleted = new Date();
          task.completed = true;
        }
      } else if (direction === 'down') {
        task.completed = false;
        task.dateCompleted = undefined;
        if (task.group.id) {
          if (task.group.completedBy) task.group.completedBy = {};
          if (task.group.assignedUsersDetail && task.group.assignedUsersDetail[user._id]) {
            task.group.assignedUsersDetail[user._id].completed = false;
            task.group.assignedUsersDetail[user._id].completedDate = undefined;
          }
          if (task.markModified) task.markModified('group');
        }
      }

      delta += _changeTaskValue(user, task, direction, times, cron);
      if (direction === 'down') delta = _calculateDelta(task, direction, cron); // recalculate delta for unchecking so the gp and exp come out correctly
      _addPoints(user, task, stats, direction, delta);

      // MP++ per checklist item in ToDo, bonus per CLI
      const multiplier = max([reduce(task.checklist, (m, i) => m + (i.completed ? 1 : 0), 1), 1]);
      _gainMP(user, max([multiplier, 0.01 * statsComputed(user).maxMP * multiplier]) * (direction === 'down' ? -1 : 1));
    }
  } else if (task.type === 'reward') {
    // Don't adjust values for rewards
    delta += _changeTaskValue(user, task, direction, times, cron);
    // purchase item
    stats.gp -= task.value;
  }

  req.yesterDailyScored = task.yesterDailyScored;
  updateStats(user, stats, req);

  if (!user.achievements.completedTask && cron === false && direction === 'up' && user.addAchievement) {
    user.addAchievement('completedTask');
    checkOnboardingStatus(user, req, analytics);
  }

  return delta;
}