David Kruger
8df9031d27
``` ~/go/bin/sourcemapper -output ddb -jsurl https://media.dndbeyond.com/character-app/static/js/main.90aa78c5.js ```
1323 lines
59 KiB
JavaScript
1323 lines
59 KiB
JavaScript
import * as actionTypes from '../actions/character/actionTypes';
|
|
import * as serviceDataActionTypes from '../actions/serviceData/actionTypes';
|
|
import { ActionAccessors } from '../engine/Action';
|
|
import { CreatureAccessors } from '../engine/Creature';
|
|
import { DataOriginTypeEnum } from '../engine/DataOrigin';
|
|
import { DefinitionHacks } from '../engine/Definition';
|
|
import { LimitedUseResetTypeEnum } from '../engine/LimitedUse';
|
|
import { SpellAccessors } from '../engine/Spell';
|
|
import { initialChoiceComponentState, } from '../generated';
|
|
import { updateSpellSlots } from './utils';
|
|
export const initialCoinState = {
|
|
cp: 0,
|
|
ep: 0,
|
|
gp: 0,
|
|
pp: 0,
|
|
sp: 0,
|
|
};
|
|
export function currencies(state = initialCoinState, action) {
|
|
let newCurrencies = state;
|
|
if (newCurrencies === null) {
|
|
newCurrencies = {
|
|
cp: 0,
|
|
ep: 0,
|
|
gp: 0,
|
|
pp: 0,
|
|
sp: 0,
|
|
};
|
|
}
|
|
switch (action.type) {
|
|
case actionTypes.CURRENCIES_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_CURRENCIES_SET_COMMIT:
|
|
return Object.assign({}, action.payload);
|
|
case actionTypes.CURRENCY_COPPER_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_COPPER_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_COPPER_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_CURRENCY_COPPER_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, newCurrencies), { cp: action.payload.amount });
|
|
case actionTypes.CURRENCY_ELECTRUM_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_ELECTRUM_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_ELECTRUM_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_CURRENCY_ELECTRUM_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, newCurrencies), { ep: action.payload.amount });
|
|
case actionTypes.CURRENCY_GOLD_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_GOLD_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_GOLD_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_CURRENCY_GOLD_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, newCurrencies), { gp: action.payload.amount });
|
|
case actionTypes.CURRENCY_PLATINUM_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_PLATINUM_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_PLATINUM_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_CURRENCY_PLATINUM_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, newCurrencies), { pp: action.payload.amount });
|
|
case actionTypes.CURRENCY_SILVER_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_SILVER_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_SILVER_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_CURRENCY_SILVER_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, newCurrencies), { sp: action.payload.amount });
|
|
case actionTypes.ITEM_CURRENCY_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_SET_COMMIT:
|
|
return state
|
|
? Object.assign(Object.assign({}, state), action.payload.currency) : Object.assign({}, action.payload.currency);
|
|
default:
|
|
//not implemented
|
|
}
|
|
return newCurrencies;
|
|
}
|
|
const initialLimitedUseState = {
|
|
maxNumberConsumed: 0,
|
|
maxUses: 0,
|
|
minNumberConsumed: 0,
|
|
name: '',
|
|
numberUsed: 0,
|
|
operator: null,
|
|
resetDice: null,
|
|
resetType: LimitedUseResetTypeEnum.SHORT_REST,
|
|
statModifierUsesId: null,
|
|
proficiencyBonusOperator: null,
|
|
useProficiencyBonus: false,
|
|
};
|
|
function limitedUse(state = initialLimitedUseState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.ACTION_USE_SET_COMMIT:
|
|
case actionTypes.SPELL_USE_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { numberUsed: action.payload.uses });
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialItemLimitedUseState = {
|
|
maxUses: 0,
|
|
numberUsed: 0,
|
|
resetType: null,
|
|
resetTypeDescription: null,
|
|
};
|
|
function itemLimitedUse(state = initialItemLimitedUseState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.ITEM_CHARGES_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CHARGES_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { numberUsed: action.payload.uses });
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialStatEntityState = {
|
|
id: -1,
|
|
value: null,
|
|
name: '',
|
|
};
|
|
function statEntity(state = initialStatEntityState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.ABILITY_SCORE_BASE_SET_COMMIT:
|
|
case actionTypes.ABILITY_SCORE_OVERRIDE_SET_COMMIT:
|
|
case actionTypes.ABILITY_SCORE_BONUS_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { value: action.payload.value });
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
function getKeyedComponentData(state, action, actionKey, key) {
|
|
if (action.payload[actionKey].hasOwnProperty(key)) {
|
|
return action.payload[actionKey][key];
|
|
}
|
|
return state[key];
|
|
}
|
|
const initialActionComponentState = {
|
|
background: [],
|
|
class: [],
|
|
feat: [],
|
|
item: [],
|
|
race: [],
|
|
};
|
|
function actionComponents(state = initialActionComponentState, action) {
|
|
if (!action.payload.hasOwnProperty('actions')) {
|
|
return state;
|
|
}
|
|
switch (action.type) {
|
|
case actionTypes.ACTIONS_SET_COMMIT:
|
|
case actionTypes.CHARACTER_COMPONENTS_SET_COMMIT:
|
|
return {
|
|
background: getKeyedComponentData(state, action, 'actions', 'background'),
|
|
class: getKeyedComponentData(state, action, 'actions', 'class'),
|
|
feat: getKeyedComponentData(state, action, 'actions', 'feat'),
|
|
item: getKeyedComponentData(state, action, 'actions', 'item'),
|
|
race: getKeyedComponentData(state, action, 'actions', 'race'),
|
|
};
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
function choiceComponents(state = initialChoiceComponentState, action) {
|
|
if (!action.payload.hasOwnProperty('choices')) {
|
|
return state;
|
|
}
|
|
switch (action.type) {
|
|
case actionTypes.CHOICES_SET_COMMIT:
|
|
case actionTypes.CHARACTER_COMPONENTS_SET_COMMIT:
|
|
return {
|
|
background: getKeyedComponentData(state, action, 'choices', 'background'),
|
|
class: getKeyedComponentData(state, action, 'choices', 'class'),
|
|
feat: getKeyedComponentData(state, action, 'choices', 'feat'),
|
|
item: getKeyedComponentData(state, action, 'choices', 'item'),
|
|
race: getKeyedComponentData(state, action, 'choices', 'race'),
|
|
choiceDefinitions: getKeyedComponentData(state, action, 'choices', 'choiceDefinitions'),
|
|
definitionKeyNameMap: getKeyedComponentData(state, action, 'choices', 'definitionKeyNameMap'),
|
|
};
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialModifierComponentState = {
|
|
background: [],
|
|
class: [],
|
|
condition: [],
|
|
feat: [],
|
|
item: [],
|
|
race: [],
|
|
};
|
|
function modifierComponents(state = initialModifierComponentState, action) {
|
|
if (!action.payload.hasOwnProperty('modifiers')) {
|
|
return state;
|
|
}
|
|
switch (action.type) {
|
|
case actionTypes.MODIFIERS_SET_COMMIT:
|
|
case actionTypes.CHARACTER_COMPONENTS_SET_COMMIT:
|
|
return {
|
|
background: getKeyedComponentData(state, action, 'modifiers', 'background'),
|
|
class: getKeyedComponentData(state, action, 'modifiers', 'class'),
|
|
condition: getKeyedComponentData(state, action, 'modifiers', 'condition'),
|
|
feat: getKeyedComponentData(state, action, 'modifiers', 'feat'),
|
|
item: getKeyedComponentData(state, action, 'modifiers', 'item'),
|
|
race: getKeyedComponentData(state, action, 'modifiers', 'race'),
|
|
};
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialOptionComponentState = {
|
|
background: [],
|
|
class: [],
|
|
feat: [],
|
|
item: [],
|
|
race: [],
|
|
};
|
|
function optionComponents(state = initialOptionComponentState, action) {
|
|
if (!action.payload.hasOwnProperty('options')) {
|
|
return state;
|
|
}
|
|
switch (action.type) {
|
|
case actionTypes.OPTIONS_SET_COMMIT:
|
|
case actionTypes.CHARACTER_COMPONENTS_SET_COMMIT:
|
|
return {
|
|
background: getKeyedComponentData(state, action, 'options', 'background'),
|
|
class: getKeyedComponentData(state, action, 'options', 'class'),
|
|
feat: getKeyedComponentData(state, action, 'options', 'feat'),
|
|
item: getKeyedComponentData(state, action, 'options', 'item'),
|
|
race: getKeyedComponentData(state, action, 'options', 'race'),
|
|
};
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialSpellComponentState = {
|
|
background: [],
|
|
class: [],
|
|
feat: [],
|
|
item: [],
|
|
race: [],
|
|
};
|
|
function spellComponents(state = initialSpellComponentState, action) {
|
|
if (!action.payload.hasOwnProperty('spells')) {
|
|
return state;
|
|
}
|
|
switch (action.type) {
|
|
case actionTypes.CHARACTER_SPELLS_SET_COMMIT:
|
|
case actionTypes.CHARACTER_COMPONENTS_SET_COMMIT:
|
|
return {
|
|
background: getKeyedComponentData(state, action, 'spells', 'background'),
|
|
class: getKeyedComponentData(state, action, 'spells', 'class'),
|
|
feat: getKeyedComponentData(state, action, 'spells', 'feat'),
|
|
item: getKeyedComponentData(state, action, 'spells', 'item'),
|
|
race: getKeyedComponentData(state, action, 'spells', 'race'),
|
|
};
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialItemState = {
|
|
chargesUsed: 0,
|
|
containerEntityId: -1,
|
|
containerEntityTypeId: -1,
|
|
containerDefinitionKey: '-1:-1',
|
|
currency: null,
|
|
definition: null,
|
|
definitionId: -1,
|
|
definitionTypeId: -1,
|
|
displayAsAttack: null,
|
|
entityTypeId: -1,
|
|
equipped: null,
|
|
equippedEntityId: null,
|
|
equippedEntityTypeId: null,
|
|
id: -1,
|
|
isAttuned: null,
|
|
limitedUse: null,
|
|
quantity: -1,
|
|
};
|
|
export function itemReducer(state = initialItemState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.ITEM_EQUIPPED_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_EQUIPPED_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { equipped: action.payload.value, equippedEntityId: action.payload.equippedEntityId, equippedEntityTypeId: action.payload.equippedEntityTypeId });
|
|
case actionTypes.ITEM_ATTUNE_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_ATTUNE_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { isAttuned: action.payload.value });
|
|
case actionTypes.ITEM_QUANTITY_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_QUANTITY_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { quantity: action.payload.quantity });
|
|
case actionTypes.ITEM_CHARGES_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CHARGES_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { limitedUse: itemLimitedUse(state.limitedUse === null ? undefined : state.limitedUse, action) });
|
|
case actionTypes.ITEM_MOVE_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_MOVE_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { containerEntityId: action.payload.containerEntityId, containerEntityTypeId: action.payload.containerEntityTypeId, containerDefinitionKey: DefinitionHacks.hack__generateDefinitionKey(action.payload.containerEntityTypeId, action.payload.containerEntityId) });
|
|
case actionTypes.ITEM_CURRENCY_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_COPPER_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_ELECTRUM_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_GOLD_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_PLATINUM_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_SILVER_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_COPPER_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_ELECTRUM_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_GOLD_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_PLATINUM_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_SILVER_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { currency: currencies(state.currency, action) });
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialInventoryState = [];
|
|
export function inventory(state = initialInventoryState, action) {
|
|
switch (action.type) {
|
|
case serviceDataActionTypes.PARTY_ITEM_EQUIPPED_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_ATTUNE_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_QUANTITY_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CHARGES_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_MOVE_SET_COMMIT:
|
|
case actionTypes.ITEM_EQUIPPED_SET_COMMIT:
|
|
case actionTypes.ITEM_ATTUNE_SET_COMMIT:
|
|
case actionTypes.ITEM_QUANTITY_SET_COMMIT:
|
|
case actionTypes.ITEM_CHARGES_SET_COMMIT:
|
|
case actionTypes.ITEM_MOVE_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_SET_COMMIT: {
|
|
const itemIdx = state.findIndex((item) => item.id === action.payload.id);
|
|
return itemIdx > -1
|
|
? [...state.slice(0, itemIdx), itemReducer(state[itemIdx], action), ...state.slice(itemIdx + 1)]
|
|
: [...state];
|
|
}
|
|
case serviceDataActionTypes.PARTY_ITEM_REMOVE_COMMIT:
|
|
case actionTypes.ITEM_REMOVE_COMMIT:
|
|
return state.filter((entity) => entity.id !== action.payload.id);
|
|
case serviceDataActionTypes.PARTY_ITEM_ADD_COMMIT:
|
|
case actionTypes.ITEM_ADD_COMMIT: {
|
|
const itemIdx = state.findIndex((item) => item.id === action.payload.item.id);
|
|
if (itemIdx > -1) {
|
|
return [...state.slice(0, itemIdx), action.payload.item, ...state.slice(itemIdx + 1)];
|
|
}
|
|
return [...state, action.payload.item];
|
|
}
|
|
case actionTypes.ITEM_CURRENCY_COPPER_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_SILVER_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_ELECTRUM_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_GOLD_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_PLATINUM_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_COPPER_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_SILVER_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_ELECTRUM_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_GOLD_SET_COMMIT:
|
|
case serviceDataActionTypes.PARTY_ITEM_CURRENCY_PLATINUM_SET_COMMIT: {
|
|
const itemIdx = state.findIndex((item) => item.id === action.payload.destinationEntityId);
|
|
return itemIdx > -1
|
|
? [...state.slice(0, itemIdx), itemReducer(state[itemIdx], action), ...state.slice(itemIdx + 1)]
|
|
: [...state];
|
|
}
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialSpellState = {
|
|
activation: null,
|
|
additionalDescription: null,
|
|
alwaysPrepared: false,
|
|
atWillLimitedUseLevel: null,
|
|
baseLevelAtWill: false,
|
|
castAtLevel: null,
|
|
castOnlyAsRitual: false,
|
|
componentId: -1,
|
|
componentTypeId: -1,
|
|
countsAsKnownSpell: false,
|
|
definition: null,
|
|
definitionId: -1,
|
|
displayAsAttack: null,
|
|
entityTypeId: -1,
|
|
id: -1,
|
|
isSignatureSpell: false,
|
|
limitedUse: null,
|
|
overrideSaveDc: null,
|
|
prepared: false,
|
|
range: null,
|
|
restriction: null,
|
|
ritualCastingType: null,
|
|
spellCastingAbilityId: null,
|
|
spellListId: null,
|
|
usesSpellSlot: false,
|
|
};
|
|
function spellEntity(state = initialSpellState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.SPELL_PREPARED_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { prepared: action.payload.prepared });
|
|
case actionTypes.SPELL_USE_SET_COMMIT:
|
|
if (!state.limitedUse) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { limitedUse: limitedUse(state.limitedUse, action) });
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialSlotEntitiesState = [];
|
|
function slotEntities(state = initialSlotEntitiesState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.SPELL_LEVEL_SPELL_SLOTS_SET_COMMIT: {
|
|
let newSpellSlots = [...state];
|
|
Object.keys(action.payload).forEach((key) => {
|
|
let spellLevel = null;
|
|
switch (key) {
|
|
case 'level1':
|
|
spellLevel = 1;
|
|
break;
|
|
case 'level2':
|
|
spellLevel = 2;
|
|
break;
|
|
case 'level3':
|
|
spellLevel = 3;
|
|
break;
|
|
case 'level4':
|
|
spellLevel = 4;
|
|
break;
|
|
case 'level5':
|
|
spellLevel = 5;
|
|
break;
|
|
case 'level6':
|
|
spellLevel = 6;
|
|
break;
|
|
case 'level7':
|
|
spellLevel = 7;
|
|
break;
|
|
case 'level8':
|
|
spellLevel = 8;
|
|
break;
|
|
case 'level9':
|
|
spellLevel = 9;
|
|
break;
|
|
}
|
|
const payloadLevelValue = action.payload[key];
|
|
const slotsUsed = payloadLevelValue === undefined ? null : payloadLevelValue;
|
|
newSpellSlots = updateSpellSlots(newSpellSlots, spellLevel, slotsUsed);
|
|
});
|
|
return newSpellSlots;
|
|
}
|
|
case actionTypes.SPELL_LEVEL_PACT_MAGIC_SLOTS_SET_COMMIT: {
|
|
let newSpellSlots = [...state];
|
|
Object.keys(action.payload).forEach((key) => {
|
|
let spellLevel = null;
|
|
switch (key) {
|
|
case 'level1':
|
|
spellLevel = 1;
|
|
break;
|
|
case 'level2':
|
|
spellLevel = 2;
|
|
break;
|
|
case 'level3':
|
|
spellLevel = 3;
|
|
break;
|
|
case 'level4':
|
|
spellLevel = 4;
|
|
break;
|
|
case 'level5':
|
|
spellLevel = 5;
|
|
break;
|
|
}
|
|
const payloadLevelValue = action.payload[key];
|
|
const slotsUsed = payloadLevelValue === undefined ? null : payloadLevelValue;
|
|
newSpellSlots = updateSpellSlots(newSpellSlots, spellLevel, slotsUsed);
|
|
});
|
|
return newSpellSlots;
|
|
}
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialClassState = {
|
|
definition: null,
|
|
definitionId: -1,
|
|
entityTypeId: -1,
|
|
id: -1,
|
|
isStartingClass: false,
|
|
level: -1,
|
|
subclassDefinition: null,
|
|
subclassDefinitionId: -1,
|
|
classFeatures: [],
|
|
hitDiceUsed: 0,
|
|
};
|
|
function classEntity(state = initialClassState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.CLASS_SET:
|
|
return Object.assign({}, action.payload);
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialOptionalClassFeatureState = {
|
|
affectedClassFeatureId: null,
|
|
affectedClassFeatureDefinitionKey: null,
|
|
classFeatureDefinitionKey: null,
|
|
classFeatureId: -1,
|
|
};
|
|
function optionalClassFeature(state = initialOptionalClassFeatureState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.OPTIONAL_CLASS_FEATURE_SET_COMMIT: {
|
|
return Object.assign(Object.assign({}, state), action.payload);
|
|
}
|
|
default:
|
|
//not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialOptionalClassFeaturesState = [];
|
|
function optionalClassFeatures(state = initialOptionalClassFeaturesState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.OPTIONAL_CLASS_FEATURE_ADD_COMMIT: {
|
|
return [...state, action.payload.optionalClassFeature];
|
|
}
|
|
case actionTypes.OPTIONAL_CLASS_FEATURE_REMOVE_COMMIT: {
|
|
return state.filter((featureMapping) => featureMapping.classFeatureId !== action.payload.classFeatureId);
|
|
}
|
|
case actionTypes.OPTIONAL_CLASS_FEATURE_SET_COMMIT: {
|
|
const optionalFeatureIndex = state.findIndex((featureMapping) => featureMapping.classFeatureId === action.payload.classFeatureId);
|
|
return [
|
|
...state.slice(0, optionalFeatureIndex),
|
|
optionalClassFeature(state[optionalFeatureIndex], action),
|
|
...state.slice(optionalFeatureIndex + 1),
|
|
];
|
|
}
|
|
default:
|
|
//not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialOptionalOriginState = {
|
|
affectedRacialTraitId: null,
|
|
affectedRacialTraitDefinitionKey: null,
|
|
racialTraitDefinitionKey: null,
|
|
racialTraitId: -1,
|
|
};
|
|
function optionalOrigin(state = initialOptionalOriginState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.OPTIONAL_ORIGIN_SET_COMMIT: {
|
|
return Object.assign(Object.assign({}, state), action.payload);
|
|
}
|
|
default:
|
|
//not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialOptionalOriginsState = [];
|
|
function optionalOrigins(state = initialOptionalOriginsState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.OPTIONAL_ORIGIN_ADD_COMMIT: {
|
|
return [...state, action.payload.optionalOrigin];
|
|
}
|
|
case actionTypes.OPTIONAL_ORIGIN_REMOVE_COMMIT: {
|
|
return state.filter((featureMapping) => featureMapping.racialTraitId !== action.payload.racialTraitId);
|
|
}
|
|
case actionTypes.OPTIONAL_ORIGIN_SET_COMMIT: {
|
|
const optionalFeatureIndex = state.findIndex((featureMapping) => featureMapping.racialTraitId === action.payload.racialTraitId);
|
|
return [
|
|
...state.slice(0, optionalFeatureIndex),
|
|
optionalOrigin(state[optionalFeatureIndex], action),
|
|
...state.slice(optionalFeatureIndex + 1),
|
|
];
|
|
}
|
|
default:
|
|
//not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialCampaignSettingState = {
|
|
campaignSettingId: 1,
|
|
enabledSourceIds: [],
|
|
};
|
|
function campaignSetting(state = initialCampaignSettingState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.CAMPAIGN_SETTING_SET_COMMIT: {
|
|
return Object.assign(Object.assign({}, state), action.payload);
|
|
}
|
|
default:
|
|
//not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialActionState = {
|
|
abilityModifierStatId: null,
|
|
actionType: null,
|
|
activation: null,
|
|
ammunition: null,
|
|
attackSubtype: null,
|
|
attackTypeRange: null,
|
|
componentId: -1,
|
|
componentTypeId: -1,
|
|
damageTypeId: null,
|
|
description: '',
|
|
dice: null,
|
|
displayAsAttack: null,
|
|
entityTypeId: null,
|
|
fixedSaveDc: null,
|
|
fixedToHit: null,
|
|
id: null,
|
|
isMartialArts: false,
|
|
isProficient: false,
|
|
limitedUse: null,
|
|
name: '',
|
|
numberOfTargets: null,
|
|
onMissDescription: '',
|
|
range: null,
|
|
saveFailDescription: '',
|
|
saveStatId: null,
|
|
saveSuccessDescription: '',
|
|
snippet: '',
|
|
spellRangeType: null,
|
|
value: null,
|
|
};
|
|
function characterAction(state = initialActionState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.ACTION_USE_SET_COMMIT:
|
|
if (!state.limitedUse) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { limitedUse: limitedUse(state.limitedUse, action) });
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialCreatureEntityState = {
|
|
definition: null,
|
|
description: null,
|
|
entityTypeId: -1,
|
|
groupId: -1,
|
|
id: -1,
|
|
isActive: false,
|
|
name: '',
|
|
removedHitPoints: 0,
|
|
temporaryHitPoints: null,
|
|
};
|
|
function creatureEntity(state = initialCreatureEntityState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.CREATURE_ACTIVE_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { isActive: action.payload.isActive });
|
|
case actionTypes.CREATURE_HIT_POINTS_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { removedHitPoints: action.payload.removedHitPoints, temporaryHitPoints: action.payload.temporaryHitPoints });
|
|
case actionTypes.CREATURE_DATA_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), action.payload.properties);
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
const initialClassSpellsEntityState = {
|
|
characterClassId: 0,
|
|
spells: [],
|
|
entityTypeId: -1,
|
|
};
|
|
function classSpellsEntity(state = initialClassSpellsEntityState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.SPELL_ADD_COMMIT:
|
|
if (state.spells === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { spells: [...state.spells, action.payload.spell] });
|
|
case actionTypes.SPELL_REMOVE_COMMIT:
|
|
if (state.spells === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { spells: state.spells.filter((spell) => !(SpellAccessors.getMappingEntityTypeId(spell) === action.payload.entityTypeId &&
|
|
SpellAccessors.getMappingId(spell) === action.payload.id)) });
|
|
case actionTypes.SPELL_PREPARED_SET_COMMIT: {
|
|
if (state.spells === null) {
|
|
return state;
|
|
}
|
|
const spellIdx = state.spells.findIndex((spell) => SpellAccessors.getMappingEntityTypeId(spell) === action.payload.entityTypeId &&
|
|
SpellAccessors.getMappingId(spell) === action.payload.id);
|
|
if (spellIdx < 0) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { spells: [
|
|
...state.spells.slice(0, spellIdx),
|
|
spellEntity(state.spells[spellIdx], action),
|
|
...state.spells.slice(spellIdx + 1),
|
|
] });
|
|
}
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
function getComponentDataOriginKey(dataOriginType) {
|
|
switch (dataOriginType) {
|
|
case DataOriginTypeEnum.BACKGROUND:
|
|
return 'background';
|
|
case DataOriginTypeEnum.CLASS_FEATURE:
|
|
return 'class';
|
|
case DataOriginTypeEnum.FEAT:
|
|
return 'feat';
|
|
case DataOriginTypeEnum.ITEM:
|
|
return 'item';
|
|
case DataOriginTypeEnum.RACE:
|
|
return 'race';
|
|
default:
|
|
// not implemented
|
|
}
|
|
return '';
|
|
}
|
|
const characterConfigInitialState = {
|
|
abilityScoreType: null,
|
|
showHelpText: false,
|
|
startingEquipmentType: null,
|
|
};
|
|
function characterConfiguration(state = characterConfigInitialState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.SHOW_HELP_TEXT_SET:
|
|
return Object.assign(Object.assign({}, state), { showHelpText: action.payload.showHelpText });
|
|
case actionTypes.ABILITY_SCORE_TYPE_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { abilityScoreType: action.payload.abilityScoreType });
|
|
case actionTypes.STARTING_EQUIPMENT_TYPE_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { startingEquipmentType: action.payload.startingEquipmentType });
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
export const initialState = {
|
|
actions: null,
|
|
activeSourceCategories: [],
|
|
adjustmentXp: null,
|
|
age: null,
|
|
alignmentId: null,
|
|
background: null,
|
|
baseHitPoints: 0,
|
|
bonusHitPoints: null,
|
|
bonusStats: [],
|
|
campaign: null,
|
|
campaignSetting: null,
|
|
canEdit: true,
|
|
characterValues: [],
|
|
choices: null,
|
|
classSpells: [],
|
|
classes: [],
|
|
conditions: [],
|
|
configuration: null,
|
|
creatures: [],
|
|
currencies: null,
|
|
currentXp: 0,
|
|
customActions: [],
|
|
customDefenseAdjustments: [],
|
|
customItems: [],
|
|
customProficiencies: [],
|
|
customSenses: [],
|
|
customSpeeds: [],
|
|
deathSaves: null,
|
|
decorations: null,
|
|
eyes: null,
|
|
faith: '',
|
|
feats: [],
|
|
gender: null,
|
|
hair: null,
|
|
height: null,
|
|
id: 0,
|
|
inspiration: false,
|
|
inventory: [],
|
|
lifestyle: null,
|
|
lifestyleId: null,
|
|
modifiers: null,
|
|
name: null,
|
|
notes: null,
|
|
optionalClassFeatures: [],
|
|
optionalOrigins: [],
|
|
options: null,
|
|
overrideHitPoints: null,
|
|
overrideStats: [],
|
|
pactMagic: [],
|
|
preferences: null,
|
|
race: null,
|
|
raceDefinitionId: null,
|
|
raceDefinitionTypeId: null,
|
|
readonlyUrl: '',
|
|
removedHitPoints: 0,
|
|
skin: null,
|
|
socialName: '',
|
|
spellSlots: [],
|
|
spells: null,
|
|
stats: [],
|
|
temporaryHitPoints: 0,
|
|
traits: null,
|
|
userId: -1,
|
|
username: '',
|
|
weight: null,
|
|
isAssignedToPlayer: false,
|
|
premadeInfo: null,
|
|
status: null,
|
|
statusSlug: null,
|
|
};
|
|
function character(state = initialState, action) {
|
|
switch (action.type) {
|
|
case actionTypes.CHARACTER_SET:
|
|
return Object.assign(Object.assign({}, state), action.payload);
|
|
case actionTypes.ALIGNMENT_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { alignmentId: action.payload.alignmentId });
|
|
case actionTypes.LIFESTYLE_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { lifestyleId: action.payload.lifestyleId });
|
|
case actionTypes.FAITH_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { faith: action.payload.faith });
|
|
case actionTypes.NAME_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { name: action.payload.name });
|
|
case actionTypes.HAIR_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { hair: action.payload.hair });
|
|
case actionTypes.SKIN_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { skin: action.payload.skin });
|
|
case actionTypes.EYES_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { eyes: action.payload.eyes });
|
|
case actionTypes.HEIGHT_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { height: action.payload.height });
|
|
case actionTypes.WEIGHT_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { weight: action.payload.weight });
|
|
case actionTypes.AGE_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { age: action.payload.age });
|
|
case actionTypes.GENDER_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { gender: action.payload.gender });
|
|
case actionTypes.RACE_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { race: action.payload.race });
|
|
case actionTypes.CLASS_ADD:
|
|
if (state.classes === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { classes: [...state.classes, action.payload.charClass] });
|
|
case actionTypes.CLASSES_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { classes: action.payload.classes });
|
|
case actionTypes.CLASS_SET: {
|
|
if (state.classes === null) {
|
|
return state;
|
|
}
|
|
const classIdx = state.classes.findIndex((charClass) => charClass.id === action.payload.id);
|
|
return Object.assign(Object.assign({}, state), { classes: [
|
|
...state.classes.slice(0, classIdx),
|
|
classEntity(state.classes[classIdx], action),
|
|
...state.classes.slice(classIdx + 1),
|
|
] });
|
|
}
|
|
case actionTypes.OPTIONAL_CLASS_FEATURE_ADD_COMMIT:
|
|
case actionTypes.OPTIONAL_CLASS_FEATURE_SET_COMMIT:
|
|
case actionTypes.OPTIONAL_CLASS_FEATURE_REMOVE_COMMIT: {
|
|
if (state.optionalClassFeatures === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { optionalClassFeatures: optionalClassFeatures(state.optionalClassFeatures, action) });
|
|
}
|
|
case actionTypes.OPTIONAL_ORIGIN_ADD_COMMIT:
|
|
case actionTypes.OPTIONAL_ORIGIN_SET_COMMIT:
|
|
case actionTypes.OPTIONAL_ORIGIN_REMOVE_COMMIT: {
|
|
if (state.optionalOrigins === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { optionalOrigins: optionalOrigins(state.optionalOrigins, action) });
|
|
}
|
|
case actionTypes.CAMPAIGN_SETTING_SET_COMMIT:
|
|
if (state.campaignSetting === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { campaignSetting: campaignSetting(state.campaignSetting, action) });
|
|
case actionTypes.NOTE_SET_COMMIT:
|
|
if (state.notes === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { notes: Object.assign(Object.assign({}, state.notes), { [action.payload.noteType]: action.payload.content }) });
|
|
case actionTypes.TRAIT_SET_COMMIT:
|
|
if (state.traits === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { traits: Object.assign(Object.assign({}, state.traits), { [action.payload.traitType]: action.payload.content }) });
|
|
case actionTypes.ITEM_REMOVE_COMMIT:
|
|
case actionTypes.ITEM_ADD_COMMIT:
|
|
case actionTypes.ITEM_EQUIPPED_SET_COMMIT:
|
|
case actionTypes.ITEM_ATTUNE_SET_COMMIT:
|
|
case actionTypes.ITEM_QUANTITY_SET_COMMIT:
|
|
case actionTypes.ITEM_CHARGES_SET_COMMIT:
|
|
case actionTypes.ITEM_MOVE_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_COPPER_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_SILVER_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_ELECTRUM_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_GOLD_SET_COMMIT:
|
|
case actionTypes.ITEM_CURRENCY_PLATINUM_SET_COMMIT:
|
|
if (state.inventory === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { inventory: inventory(state.inventory, action) });
|
|
case actionTypes.CUSTOM_ITEM_ADD_COMMIT:
|
|
if (state.customItems === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customItems: [...state.customItems, action.payload.item] });
|
|
case actionTypes.CUSTOM_ITEM_SET_COMMIT: {
|
|
if (state.customItems === null) {
|
|
return state;
|
|
}
|
|
const itemIdx = state.customItems.findIndex((item) => item.id === action.payload.id);
|
|
const item = Object.assign(Object.assign({}, state.customItems[itemIdx]), action.payload.properties);
|
|
return Object.assign(Object.assign({}, state), { customItems: [...state.customItems.slice(0, itemIdx), item, ...state.customItems.slice(itemIdx + 1)] });
|
|
}
|
|
case actionTypes.CUSTOM_ITEM_REMOVE_COMMIT:
|
|
if (state.customItems === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customItems: state.customItems.filter((item) => item.id !== action.payload.id) });
|
|
case actionTypes.XP_SET:
|
|
return Object.assign(Object.assign({}, state), { currentXp: action.payload.currentXp });
|
|
case actionTypes.BASE_HIT_POINTS_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { baseHitPoints: action.payload.baseHitPoints });
|
|
case actionTypes.BONUS_HIT_POINTS_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { bonusHitPoints: action.payload.bonusHitPoints });
|
|
case actionTypes.OVERRIDE_HIT_POINTS_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { overrideHitPoints: action.payload.overrideHitPoints });
|
|
case actionTypes.ABILITY_SCORE_BASE_SET_COMMIT: {
|
|
if (state.stats === null) {
|
|
return state;
|
|
}
|
|
const statIdx = state.stats.findIndex((stat) => stat.id === action.payload.statId);
|
|
return Object.assign(Object.assign({}, state), { stats: [
|
|
...state.stats.slice(0, statIdx),
|
|
statEntity(state.stats[statIdx], action),
|
|
...state.stats.slice(statIdx + 1),
|
|
] });
|
|
}
|
|
case actionTypes.ABILITY_SCORE_OVERRIDE_SET_COMMIT: {
|
|
if (state.overrideStats === null) {
|
|
return state;
|
|
}
|
|
const statIdx = state.overrideStats.findIndex((stat) => stat.id === action.payload.statId);
|
|
return Object.assign(Object.assign({}, state), { overrideStats: [
|
|
...state.overrideStats.slice(0, statIdx),
|
|
statEntity(state.overrideStats[statIdx], action),
|
|
...state.overrideStats.slice(statIdx + 1),
|
|
] });
|
|
}
|
|
case actionTypes.ABILITY_SCORE_BONUS_SET_COMMIT: {
|
|
if (state.bonusStats === null) {
|
|
return state;
|
|
}
|
|
const statIdx = state.bonusStats.findIndex((stat) => stat.id === action.payload.statId);
|
|
return Object.assign(Object.assign({}, state), { bonusStats: [
|
|
...state.bonusStats.slice(0, statIdx),
|
|
statEntity(state.bonusStats[statIdx], action),
|
|
...state.bonusStats.slice(statIdx + 1),
|
|
] });
|
|
}
|
|
case actionTypes.CURRENCIES_SET_COMMIT:
|
|
case actionTypes.CURRENCY_COPPER_SET_COMMIT:
|
|
case actionTypes.CURRENCY_ELECTRUM_SET_COMMIT:
|
|
case actionTypes.CURRENCY_GOLD_SET_COMMIT:
|
|
case actionTypes.CURRENCY_PLATINUM_SET_COMMIT:
|
|
case actionTypes.CURRENCY_SILVER_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { currencies: currencies(state.currencies, action) });
|
|
case actionTypes.SPELL_PREPARED_SET_COMMIT:
|
|
case actionTypes.SPELL_ADD_COMMIT:
|
|
case actionTypes.SPELL_REMOVE_COMMIT: {
|
|
if (state.classSpells === null) {
|
|
return state;
|
|
}
|
|
const classSpellIdx = state.classSpells.findIndex((classSpell) => classSpell.characterClassId === action.payload.characterClassId);
|
|
if (classSpellIdx < 0) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { classSpells: [
|
|
...state.classSpells.slice(0, classSpellIdx),
|
|
classSpellsEntity(state.classSpells[classSpellIdx], action),
|
|
...state.classSpells.slice(classSpellIdx + 1),
|
|
] });
|
|
}
|
|
case actionTypes.BACKGROUND_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { background: action.payload.background });
|
|
case actionTypes.BACKGROUND_HAS_CUSTOM_SET_COMMIT:
|
|
if (state.background === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { background: Object.assign(Object.assign({}, state.background), { hasCustomBackground: action.payload.hasCustomBackground }) });
|
|
case actionTypes.FEATS_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { feats: [...action.payload.feats] });
|
|
case actionTypes.PREFERENCE_SET_COMMIT:
|
|
if (state.preferences === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { preferences: Object.assign(Object.assign({}, state.preferences), action.payload) });
|
|
case actionTypes.ACTIVE_SOURCE_CATEGORIES_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { activeSourceCategories: action.payload.activeSourceCategories });
|
|
case actionTypes.PORTRAIT_SET_COMMIT:
|
|
if (state.decorations === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { decorations: Object.assign(Object.assign({}, state.decorations), { avatarId: action.payload.avatarId, avatarUrl: action.payload.avatarUrl }) });
|
|
case actionTypes.HIT_POINTS_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { removedHitPoints: action.payload.removedHitPoints, temporaryHitPoints: action.payload.temporaryHitPoints });
|
|
case actionTypes.CONDITIONS_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { conditions: [...action.payload.conditions] });
|
|
case actionTypes.XP_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { currentXp: action.payload.currentXp });
|
|
case actionTypes.INSPIRATION_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { inspiration: action.payload.inspiration });
|
|
case actionTypes.DEATHSAVES_SET_COMMIT:
|
|
if (state.deathSaves === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { deathSaves: Object.assign(Object.assign({}, state.deathSaves), { failCount: action.payload.fails, successCount: action.payload.successes }) });
|
|
case actionTypes.MOVEMENT_ADD_COMMIT:
|
|
if (state.customSpeeds === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customSpeeds: [...state.customSpeeds, action.payload] });
|
|
case actionTypes.MOVEMENT_SET_COMMIT:
|
|
if (state.customSpeeds === null) {
|
|
return state;
|
|
}
|
|
const customSpeedIdx = state.customSpeeds.findIndex((speed) => speed.movementId === action.payload.movementId);
|
|
return Object.assign(Object.assign({}, state), { customSpeeds: [
|
|
...state.customSpeeds.slice(0, customSpeedIdx),
|
|
Object.assign({}, action.payload),
|
|
...state.customSpeeds.slice(customSpeedIdx + 1),
|
|
] });
|
|
case actionTypes.MOVEMENT_REMOVE_COMMIT:
|
|
if (state.customSpeeds === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customSpeeds: state.customSpeeds.filter((movement) => movement.movementId !== action.payload.movementId) });
|
|
case actionTypes.SENSE_ADD_COMMIT:
|
|
if (state.customSenses === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customSenses: [...state.customSenses, action.payload] });
|
|
case actionTypes.SENSE_SET_COMMIT:
|
|
if (state.customSenses === null) {
|
|
return state;
|
|
}
|
|
const customSenseIdx = state.customSenses.findIndex((sense) => sense.senseId === action.payload.senseId);
|
|
return Object.assign(Object.assign({}, state), { customSenses: [
|
|
...state.customSenses.slice(0, customSenseIdx),
|
|
Object.assign({}, action.payload),
|
|
...state.customSenses.slice(customSenseIdx + 1),
|
|
] });
|
|
case actionTypes.SENSE_REMOVE_COMMIT:
|
|
if (state.customSenses === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customSenses: state.customSenses.filter((sense) => sense.senseId !== action.payload.senseId) });
|
|
case actionTypes.CUSTOM_ACTION_ADD_COMMIT:
|
|
if (state.customActions === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customActions: [...state.customActions, action.payload.action] });
|
|
case actionTypes.CUSTOM_ACTION_REMOVE_COMMIT:
|
|
if (state.customActions === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customActions: state.customActions.filter((attack) => attack.id !== action.payload.id) });
|
|
case actionTypes.CUSTOM_ACTION_SET_COMMIT: {
|
|
if (state.customActions === null) {
|
|
return state;
|
|
}
|
|
const customActionIdx = state.customActions.findIndex((attack) => attack.id === action.payload.id);
|
|
return Object.assign(Object.assign({}, state), { customActions: [
|
|
...state.customActions.slice(0, customActionIdx),
|
|
Object.assign(Object.assign({}, state.customActions[customActionIdx]), action.payload.properties),
|
|
...state.customActions.slice(customActionIdx + 1),
|
|
] });
|
|
}
|
|
// TODO this needs data update
|
|
case actionTypes.CUSTOM_PROFICIENCY_ADD_COMMIT:
|
|
if (state.customProficiencies === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customProficiencies: [...state.customProficiencies, action.payload.proficiency] });
|
|
case actionTypes.CUSTOM_PROFICIENCY_REMOVE_COMMIT:
|
|
if (state.customProficiencies === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customProficiencies: state.customProficiencies.filter((proficiency) => proficiency.id !== action.payload.id) });
|
|
case actionTypes.CUSTOM_PROFICIENCY_SET_COMMIT: {
|
|
if (state.customProficiencies === null) {
|
|
return state;
|
|
}
|
|
const customProfIdx = state.customProficiencies.findIndex((proficiency) => proficiency.id === action.payload.id);
|
|
return Object.assign(Object.assign({}, state), { customProficiencies: [
|
|
...state.customProficiencies.slice(0, customProfIdx),
|
|
Object.assign(Object.assign({}, state.customProficiencies[customProfIdx]), action.payload.properties),
|
|
...state.customProficiencies.slice(customProfIdx + 1),
|
|
] });
|
|
}
|
|
case actionTypes.CUSTOM_DEFENSE_ADJUSTMENT_ADD_COMMIT:
|
|
if (state.customDefenseAdjustments === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customDefenseAdjustments: [...state.customDefenseAdjustments, action.payload] });
|
|
case actionTypes.CUSTOM_DEFENSE_ADJUSTMENT_SET_COMMIT:
|
|
if (state.customDefenseAdjustments === null) {
|
|
return state;
|
|
}
|
|
const customDefenseIdx = state.customDefenseAdjustments.findIndex((adjustment) => adjustment.adjustmentId === action.payload.adjustmentId && adjustment.type === action.payload.type);
|
|
return Object.assign(Object.assign({}, state), { customDefenseAdjustments: [
|
|
...state.customDefenseAdjustments.slice(0, customDefenseIdx),
|
|
Object.assign({}, action.payload),
|
|
...state.customDefenseAdjustments.slice(customDefenseIdx + 1),
|
|
] });
|
|
case actionTypes.CUSTOM_DEFENSE_ADJUSTMENT_REMOVE_COMMIT:
|
|
if (state.customDefenseAdjustments === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { customDefenseAdjustments: state.customDefenseAdjustments.filter((adjustment) => !(adjustment.type === action.payload.type &&
|
|
adjustment.adjustmentId === action.payload.adjustmentId)) });
|
|
case actionTypes.FRAME_SET_COMMIT:
|
|
if (state.decorations === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { decorations: Object.assign(Object.assign({}, state.decorations), { frameAvatarId: action.payload.frame.frameAvatarId, frameAvatarUrl: action.payload.frame.frameAvatarUrl, frameAvatarDecorationKey: action.payload.frame.decorationKey }) });
|
|
case actionTypes.THEME_SET_COMMIT:
|
|
if (state.decorations === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { decorations: Object.assign(Object.assign({}, state.decorations), { themeColor: action.payload.themeColor }) });
|
|
case actionTypes.BACKDROP_SET_COMMIT: {
|
|
const { backdropAvatarId, backdropAvatarUrl, largeBackdropAvatarId, largeBackdropAvatarUrl, smallBackdropAvatarId, smallBackdropAvatarUrl, thumbnailBackdropAvatarId, thumbnailBackdropAvatarUrl, } = action.payload.backdrop;
|
|
if (state.decorations === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { decorations: Object.assign(Object.assign({}, state.decorations), { backdropAvatarId,
|
|
backdropAvatarUrl,
|
|
largeBackdropAvatarId,
|
|
largeBackdropAvatarUrl,
|
|
smallBackdropAvatarId,
|
|
smallBackdropAvatarUrl,
|
|
thumbnailBackdropAvatarId,
|
|
thumbnailBackdropAvatarUrl }) });
|
|
}
|
|
case actionTypes.SPELL_LEVEL_PACT_MAGIC_SLOTS_SET_COMMIT:
|
|
if (state.pactMagic === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { pactMagic: slotEntities(state.pactMagic, action) });
|
|
case actionTypes.SPELL_LEVEL_SPELL_SLOTS_SET_COMMIT:
|
|
if (state.spellSlots === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { spellSlots: slotEntities(state.spellSlots, action) });
|
|
case actionTypes.ACTION_USE_SET_COMMIT: {
|
|
if (state.actions === null) {
|
|
return state;
|
|
}
|
|
const componentDataOriginKey = getComponentDataOriginKey(action.payload.dataOriginType);
|
|
const actionIdx = state.actions[componentDataOriginKey].findIndex((charAction) => ActionAccessors.getId(charAction) === action.payload.id &&
|
|
ActionAccessors.getEntityTypeId(charAction) === action.payload.entityTypeId);
|
|
return Object.assign(Object.assign({}, state), { actions: Object.assign(Object.assign({}, state.actions), { [componentDataOriginKey]: [
|
|
...state.actions[componentDataOriginKey].slice(0, actionIdx),
|
|
characterAction(state.actions[componentDataOriginKey][actionIdx], action),
|
|
...state.actions[componentDataOriginKey].slice(actionIdx + 1),
|
|
] }) });
|
|
}
|
|
case actionTypes.SPELL_USE_SET_COMMIT: {
|
|
if (state.spells === null) {
|
|
return state;
|
|
}
|
|
const componentDataOriginKey = getComponentDataOriginKey(action.payload.dataOriginType);
|
|
const spellIdx = state.spells[componentDataOriginKey].findIndex((spell) => SpellAccessors.getMappingId(spell) === action.payload.id &&
|
|
SpellAccessors.getMappingEntityTypeId(spell) === action.payload.entityTypeId);
|
|
return Object.assign(Object.assign({}, state), { spells: Object.assign(Object.assign({}, state.spells), { [componentDataOriginKey]: [
|
|
...state.spells[componentDataOriginKey].slice(0, spellIdx),
|
|
spellEntity(state.spells[componentDataOriginKey][spellIdx], action),
|
|
...state.spells[componentDataOriginKey].slice(spellIdx + 1),
|
|
] }) });
|
|
}
|
|
case actionTypes.CHOICES_SET_COMMIT:
|
|
if (state.choices === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { choices: choiceComponents(state.choices, action) });
|
|
case actionTypes.MODIFIERS_SET_COMMIT:
|
|
if (state.modifiers === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { modifiers: modifierComponents(state.modifiers, action) });
|
|
case actionTypes.ACTIONS_SET_COMMIT:
|
|
if (state.actions === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { actions: actionComponents(state.actions, action) });
|
|
case actionTypes.PACT_MAGIC_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { pactMagic: action.payload.pactMagic });
|
|
case actionTypes.SPELLS_SLOTS_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { spellSlots: action.payload.spellSlots });
|
|
case actionTypes.CHARACTER_SPELLS_SET_COMMIT:
|
|
if (state.spells === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { spells: spellComponents(state.spells, action) });
|
|
case actionTypes.OPTIONS_SET_COMMIT:
|
|
if (state.options === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { options: optionComponents(state.options, action) });
|
|
case actionTypes.CHARACTER_COMPONENTS_SET_COMMIT: {
|
|
let updatedState = Object.assign({}, state);
|
|
if (state.actions !== null) {
|
|
updatedState = Object.assign(Object.assign({}, updatedState), { actions: actionComponents(state.actions, action) });
|
|
}
|
|
if (state.choices !== null) {
|
|
updatedState = Object.assign(Object.assign({}, updatedState), { choices: choiceComponents(state.choices, action) });
|
|
}
|
|
if (state.modifiers !== null) {
|
|
updatedState = Object.assign(Object.assign({}, updatedState), { modifiers: modifierComponents(state.modifiers, action) });
|
|
}
|
|
if (state.options !== null) {
|
|
updatedState = Object.assign(Object.assign({}, updatedState), { options: optionComponents(state.options, action) });
|
|
}
|
|
if (state.spells !== null) {
|
|
updatedState = Object.assign(Object.assign({}, updatedState), { spells: spellComponents(state.spells, action) });
|
|
}
|
|
if (state.classSpells !== null && action.payload.classSpells) {
|
|
updatedState = Object.assign(Object.assign({}, updatedState), { classSpells: [...action.payload.classSpells] });
|
|
}
|
|
return updatedState;
|
|
}
|
|
case actionTypes.VALUE_SET_COMMIT: {
|
|
if (state.characterValues === null) {
|
|
return state;
|
|
}
|
|
// TODO move this to a saga handler that uses an existing lookup to test for presence
|
|
const { typeId, value, notes, valueId, valueTypeId, contextId, contextTypeId } = action.payload;
|
|
const valueInfo = {
|
|
typeId,
|
|
value,
|
|
notes,
|
|
valueId,
|
|
valueTypeId,
|
|
contextId,
|
|
contextTypeId,
|
|
};
|
|
const idx = state.characterValues.findIndex((charValue) => charValue.typeId === typeId &&
|
|
charValue.valueId === valueId &&
|
|
charValue.valueTypeId === valueTypeId &&
|
|
charValue.contextId === contextId &&
|
|
charValue.contextTypeId === contextTypeId);
|
|
if (idx > -1 && value === null && notes === null) {
|
|
return Object.assign(Object.assign({}, state), { characterValues: state.characterValues.filter((charValue, valueIdx) => valueIdx !== idx) });
|
|
}
|
|
let newCharacterValues;
|
|
if (idx > -1) {
|
|
newCharacterValues = [
|
|
...state.characterValues.slice(0, idx),
|
|
valueInfo,
|
|
...state.characterValues.slice(idx + 1),
|
|
];
|
|
}
|
|
else {
|
|
newCharacterValues = [...state.characterValues, valueInfo];
|
|
}
|
|
return Object.assign(Object.assign({}, state), { characterValues: newCharacterValues });
|
|
}
|
|
case actionTypes.VALUE_REMOVE_COMMIT: {
|
|
if (state.characterValues === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { characterValues: state.characterValues.filter((charValue) => !(charValue.typeId === action.payload.typeId &&
|
|
charValue.valueId === action.payload.valueId &&
|
|
charValue.valueTypeId === action.payload.valueTypeId &&
|
|
charValue.contextId === action.payload.contextId &&
|
|
charValue.contextTypeId === action.payload.contextTypeId)) });
|
|
}
|
|
case actionTypes.ENTITY_VALUES_REMOVE_COMMIT: {
|
|
if (state.characterValues === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { characterValues: state.characterValues.filter((charValue) => !(charValue.valueId === action.payload.valueId &&
|
|
charValue.valueTypeId === action.payload.valueTypeId &&
|
|
charValue.contextId === action.payload.contextId &&
|
|
charValue.contextTypeId === action.payload.contextTypeId)) });
|
|
}
|
|
case actionTypes.CREATURE_ADD_COMMIT:
|
|
if (state.creatures === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { creatures: [...state.creatures, action.payload.creature] });
|
|
case actionTypes.CREATURE_REMOVE_COMMIT:
|
|
if (state.creatures === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { creatures: state.creatures.filter((creature) => action.payload.id !== CreatureAccessors.getMappingId(creature)) });
|
|
case actionTypes.CREATURE_DATA_SET_COMMIT:
|
|
case actionTypes.CREATURE_ACTIVE_SET_COMMIT:
|
|
case actionTypes.CREATURE_HIT_POINTS_SET_COMMIT: {
|
|
if (state.creatures === null) {
|
|
return state;
|
|
}
|
|
const idx = state.creatures.findIndex((creature) => action.payload.id === CreatureAccessors.getMappingId(creature));
|
|
return Object.assign(Object.assign({}, state), { creatures: [
|
|
...state.creatures.slice(0, idx),
|
|
creatureEntity(state.creatures[idx], action),
|
|
...state.creatures.slice(idx + 1),
|
|
] });
|
|
}
|
|
case actionTypes.ABILITY_SCORE_TYPE_SET_COMMIT:
|
|
case actionTypes.SHOW_HELP_TEXT_SET:
|
|
case actionTypes.STARTING_EQUIPMENT_TYPE_SET_COMMIT:
|
|
if (state.configuration === null) {
|
|
return state;
|
|
}
|
|
return Object.assign(Object.assign({}, state), { configuration: characterConfiguration(state.configuration, action) });
|
|
case actionTypes.ACTIVE_SOURCES_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { campaignSetting: action.payload });
|
|
case actionTypes.PREMADE_INFO_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { premadeInfo: action.payload });
|
|
case actionTypes.PREMADE_INFO_REMOVE_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { premadeInfo: null });
|
|
case actionTypes.STATUS_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { status: action.payload.status });
|
|
case actionTypes.STATUS_SLUG_SET_COMMIT:
|
|
return Object.assign(Object.assign({}, state), { statusSlug: action.payload.statusSlug });
|
|
default:
|
|
// not implemented
|
|
}
|
|
return state;
|
|
}
|
|
export default character;
|