= (
27 | sessionProps: SP,
28 | dispatchProps: DP,
29 | ownProps: OP
30 | ) => P
31 |
32 | declare type StatelessComponent = (props: P) => ?React$Element
33 |
34 | declare class ConnectedComponent
35 | extends React$Component {
36 | static WrappedComponent: Class>,
37 | getWrappedInstance(): React$Component,
38 | static defaultProps: void,
39 | props: OP,
40 | session: void
41 | }
42 |
43 | declare type ConnectedComponentClass = Class<
44 | ConnectedComponent
45 | >
46 |
47 | declare type Connector = {
48 | (
49 | component: StatelessComponent
50 | ): ConnectedComponentClass,
51 | (
52 | component: Class>
53 | ): ConnectedComponentClass
54 | }
55 |
56 | declare class Provider
57 | extends React$Component<
58 | void,
59 | { store: Store, children?: any },
60 | void
61 | > {}
62 |
63 | declare type ConnectOptions = {
64 | pure?: boolean,
65 | withRef?: boolean
66 | }
67 |
68 | declare type Null = null | void
69 |
70 | declare function connect(
71 | ...rest: Array // <= workaround for https://github.com/facebook/flow/issues/2360
72 | ): Connector } & OP>>
73 |
74 | declare function connect(
75 | mapStateToProps: Null,
76 | mapDispatchToProps: Null,
77 | mergeProps: Null,
78 | options: ConnectOptions
79 | ): Connector } & OP>>
80 |
81 | declare function connect(
82 | mapStateToProps: MapStateToProps,
83 | mapDispatchToProps: Null,
84 | mergeProps: Null,
85 | options?: ConnectOptions
86 | ): Connector } & OP>>
87 |
88 | declare function connect(
89 | mapStateToProps: Null,
90 | mapDispatchToProps: MapDispatchToProps,
91 | mergeProps: Null,
92 | options?: ConnectOptions
93 | ): Connector>
94 |
95 | declare function connect(
96 | mapStateToProps: MapStateToProps,
97 | mapDispatchToProps: MapDispatchToProps,
98 | mergeProps: Null,
99 | options?: ConnectOptions
100 | ): Connector>
101 |
102 | declare function connect(
103 | mapStateToProps: MapStateToProps,
104 | mapDispatchToProps: MapDispatchToProps,
105 | mergeProps: MergeProps,
106 | options?: ConnectOptions
107 | ): Connector
108 | }
109 |
--------------------------------------------------------------------------------
/src/domain/battle/BattleSession.js:
--------------------------------------------------------------------------------
1 | /* @flow */
2 | import * as BattlerActions from './Battler'
3 | import * as BattlerFactory from './BattlerFactory'
4 | import type { Battler } from './Battler'
5 | import type { Command, CommandApplicationProgress } from './Command'
6 | import type { CommandResult } from './CommandResult'
7 | import type { Input } from './Input'
8 | import type { BattleSessionResult } from './BattleSessionResult'
9 | import { battleStateMock0 } from './__mock/battleStateMock'
10 | import type { AdventureSession } from 'domain/adventure/AdventureSession'
11 |
12 | // State
13 | export type BattleSession = {
14 | battlers: Battler[],
15 | turn: number
16 | }
17 |
18 | export function buildBattleSession(ps: AdventureSession): BattleSession {
19 | const allies = BattlerFactory.buildAllyBattlers(ps.actors)
20 | const enemies = BattlerFactory.buildEnemyBattlers([
21 | {
22 | monsterId: '$goblin'
23 | },
24 | {
25 | monsterId: '$hob-goblin'
26 | }
27 | ])
28 | return {
29 | turn: 0,
30 | battlers: allies.concat(enemies)
31 | }
32 | }
33 |
34 | export function processPreUpdatePhase(session: BattleSession): BattleSession {
35 | return {
36 | ...session,
37 | battlers: session.battlers.map(BattlerActions.updateBattlerState)
38 | }
39 | }
40 |
41 | export function processPlanningPhase(
42 | session: BattleSession,
43 | inputQueue: Input[]
44 | ): Command[] {
45 | return Object.freeze(
46 | session.battlers.reduce((commands, battler) => {
47 | const inputs = inputQueue.filter(input => input.battlerId === battler.id)
48 | return commands.concat(
49 | BattlerActions.planNextCommand(battler, inputs, session)
50 | )
51 | }, [])
52 | )
53 | }
54 |
55 | export function processCommandExecPhase(
56 | session: BattleSession,
57 | commandQueue: Command[]
58 | ): CommandApplicationProgress {
59 | return Object.freeze(
60 | commandQueue.reduce(
61 | (next: CommandApplicationProgress, nextCmd: Command) => {
62 | const { session: nextState, commandResults } = nextCmd(next.session)
63 | return {
64 | session: nextState,
65 | commandResults: next.commandResults.concat(commandResults)
66 | }
67 | },
68 | { session, commandResults: [] }
69 | )
70 | )
71 | }
72 |
73 | export function isBattleFinished(session: BattleSession): ?BattleSessionResult {
74 | if (
75 | session.battlers.filter(b => b.side === 'enemy').every(b => b.life.val <= 0)
76 | ) {
77 | return {
78 | winner: 'ally',
79 | rewards: {
80 | resources: [
81 | {
82 | resourceId: '$gold',
83 | resourceName: 'gold',
84 | amount: 30
85 | }
86 | ]
87 | }
88 | }
89 | }
90 |
91 | if (
92 | session.battlers.filter(b => b.side === 'ally').every(b => b.life.val <= 0)
93 | ) {
94 | return { winner: 'enemy' }
95 | }
96 |
97 | return null
98 | }
99 |
100 | export function processTurn(
101 | session: BattleSession,
102 | inputQueue: Input[]
103 | ): { session: BattleSession, commandResults: CommandResult[] } {
104 | // update pre-actions
105 | const preUpdatedState = processPreUpdatePhase(session)
106 |
107 | // create commands
108 | const commandQueue = processPlanningPhase(preUpdatedState, inputQueue)
109 |
110 | // exec commands
111 | return processCommandExecPhase(preUpdatedState, commandQueue)
112 | }
113 |
114 | export function createBattleSession(): BattleSession {
115 | // TODO: Return real session
116 | return battleStateMock0
117 | }
118 |
--------------------------------------------------------------------------------
/src/client/actions/battleActions.js:
--------------------------------------------------------------------------------
1 | /* @flow */
2 | import type { AdventureSession } from 'domain/adventure/AdventureSession'
3 | import type { Input, BattleSessionResult } from 'domain/battle'
4 | import { createNoTargetedSkillInput } from 'domain/battle'
5 |
6 | // Constants
7 | export const REQUEST_START = 'battle:request-start'
8 | export const REQUEST_PAUSE = 'battle:request-pause'
9 | export const REQUEST_RESTART = 'battle:request-restart'
10 | export const PAUSED = 'battle:paused'
11 | export const RESTARTED = 'battle:restarted'
12 | export const OPEN_BATTLE_SESSION_RESULT = 'battle:open-battle-session-result'
13 | export const EXIT_BATTLE_SESSION = 'battle:exit-battle-session'
14 | export const ADD_INPUT_TO_QUEUE = 'battle:add-input-to-queue'
15 | export const UPDATE_INPUT_QUEUE = 'battle:update-input-queue'
16 | export const MOVE_SKILL_SELECTOR = 'battle:move-skill-selector'
17 | export const SET_SKILL_SELECTOR = 'battle:set-skill-selector'
18 | export const UNSET_SKILL_SELECTOR = 'battle:unset-skill-selector'
19 | export const RESET = 'battle:reset'
20 | export const LOG = 'battle:log'
21 |
22 | // Actions
23 | export type BattleAction =
24 | | {
25 | type: typeof REQUEST_START,
26 | payload: { adventureSession: AdventureSession }
27 | }
28 | | { type: typeof REQUEST_PAUSE }
29 | | { type: typeof REQUEST_RESTART }
30 | | { type: typeof PAUSED }
31 | | { type: typeof RESTARTED }
32 | | { type: typeof RESET }
33 | | { type: typeof MOVE_SKILL_SELECTOR, payload: { dx: number, dy: number } }
34 | | { type: typeof SET_SKILL_SELECTOR, payload: { x: number, y: number } }
35 | | { type: typeof UNSET_SKILL_SELECTOR }
36 | | {
37 | type: typeof OPEN_BATTLE_SESSION_RESULT,
38 | payload: BattleSessionResult
39 | }
40 | | {
41 | type: typeof EXIT_BATTLE_SESSION
42 | }
43 | | { type: typeof LOG, payload: string }
44 | | {
45 | type: typeof ADD_INPUT_TO_QUEUE,
46 | payload: {
47 | battlerId: string,
48 | skillId: string
49 | }
50 | }
51 | | {
52 | type: typeof UPDATE_INPUT_QUEUE,
53 | payload: {
54 | inputQueue: Input[]
55 | }
56 | }
57 |
58 | // Action creator
59 | export const requestStart = (adventureSession: AdventureSession) => ({
60 | type: REQUEST_START,
61 | payload: {
62 | adventureSession
63 | }
64 | })
65 | export const requestPause = () => ({ type: REQUEST_PAUSE })
66 | export const requestRestart = () => ({ type: REQUEST_RESTART })
67 | export const paused = () => ({ type: PAUSED })
68 | export const restarted = () => ({ type: RESTARTED })
69 | export const reset = () => ({ type: RESET })
70 |
71 | // Skill Selector
72 | export const moveSkillSelector = (dx: number, dy: number) => ({
73 | type: MOVE_SKILL_SELECTOR,
74 | payload: { dx, dy }
75 | })
76 | export const setSkillSelector = (x: number, y: number) => ({
77 | type: SET_SKILL_SELECTOR,
78 | payload: { x, y }
79 | })
80 | export const unsetSkillSelector = () => ({
81 | type: UNSET_SKILL_SELECTOR
82 | })
83 |
84 | export const openBattleSessionResult = (result: BattleSessionResult) => ({
85 | type: OPEN_BATTLE_SESSION_RESULT,
86 | payload: result
87 | })
88 | export const closeBattleSessionResult = () => ({ type: EXIT_BATTLE_SESSION })
89 | export const log = (message: string) => ({ type: LOG, payload: message })
90 | export const addInputToQueue = (battlerId: string, skillId: string) => {
91 | return {
92 | type: ADD_INPUT_TO_QUEUE,
93 | payload: createNoTargetedSkillInput(battlerId, skillId)
94 | }
95 | }
96 | export const updateInputQueue = (inputQueue: Input[]) => ({
97 | type: UPDATE_INPUT_QUEUE,
98 | payload: { inputQueue }
99 | })
100 |
--------------------------------------------------------------------------------
/src/client/reducers/battle/runner.js:
--------------------------------------------------------------------------------
1 | /* @flow */
2 | import {
3 | PAUSED,
4 | REQUEST_START,
5 | RESET,
6 | RESTARTED,
7 | UPDATE_INPUT_QUEUE,
8 | MOVE_SKILL_SELECTOR,
9 | SET_SKILL_SELECTOR,
10 | UNSET_SKILL_SELECTOR,
11 | OPEN_BATTLE_SESSION_RESULT,
12 | EXIT_BATTLE_SESSION
13 | } from '../../actions/battleActions'
14 | import type { BattleSagaAction } from '../../actions/battleSagaActions'
15 | import { SYNC } from '../../actions/battleSagaActions'
16 | import type { BattleAction } from '../../actions/battleActions'
17 | import type {
18 | BattleSession,
19 | Input,
20 | BattleSessionResult,
21 | Battler
22 | } from 'domain/battle'
23 |
24 | // State
25 | export type SkillSelector = {
26 | x: number,
27 | y: number
28 | }
29 | export type State = {
30 | battleSession: ?BattleSession,
31 | inputQueue: Input[],
32 | loading: boolean,
33 | paused: boolean,
34 | skillSelectCursor: ?SkillSelector,
35 | battleSessionResult: ?BattleSessionResult
36 | }
37 |
38 | const initialState: State = Object.freeze({
39 | loading: true,
40 | paused: false,
41 | battleSession: null,
42 | inputQueue: [],
43 | skillSelectCursor: { x: 0, y: 0 },
44 | battleSessionResult: null
45 | })
46 |
47 | // Reducer
48 | export default (
49 | state: State = initialState,
50 | action: BattleAction | BattleSagaAction
51 | ) => {
52 | switch (action.type) {
53 | case REQUEST_START:
54 | return {
55 | ...state,
56 | battleSession: null,
57 | loading: false
58 | }
59 | case PAUSED:
60 | return {
61 | ...state,
62 | paused: true
63 | }
64 | case RESTARTED:
65 | return {
66 | ...state,
67 | paused: false
68 | }
69 | case SYNC:
70 | return {
71 | ...state,
72 | battleSession: action.payload,
73 | loading: true
74 | }
75 | case OPEN_BATTLE_SESSION_RESULT:
76 | return {
77 | ...state,
78 | battleSessionResult: action.payload
79 | }
80 | case EXIT_BATTLE_SESSION:
81 | return initialState
82 | case UPDATE_INPUT_QUEUE:
83 | return {
84 | ...state,
85 | inputQueue: action.payload.inputQueue
86 | }
87 | case SET_SKILL_SELECTOR:
88 | return {
89 | ...state,
90 | skillSelectCursor: action.payload
91 | }
92 | case UNSET_SKILL_SELECTOR:
93 | return {
94 | ...state,
95 | skillSelectCursor: null
96 | }
97 | case MOVE_SKILL_SELECTOR:
98 | if (state.skillSelectCursor && state.battleSession) {
99 | const { skillSelectCursor, battleSession } = state
100 | const allies = battleSession.battlers.filter(b => b.side === 'ally')
101 | const { x, y } = skillSelectCursor
102 | const { dx, dy } = action.payload
103 | return {
104 | ...state,
105 | skillSelectCursor: moveSkillCursorWithOverflow(allies, x + dx, y + dy)
106 | }
107 | } else {
108 | return {
109 | ...state,
110 | skillSelectCursor: { x: 0, y: 0 }
111 | }
112 | }
113 | case RESET:
114 | return initialState
115 | default:
116 | return state
117 | }
118 | }
119 |
120 | const { abs } = Math
121 | function moveSkillCursorWithOverflow(
122 | battlers: Battler[],
123 | x: number,
124 | y: number
125 | ): { x: number, y: number } {
126 | // select battler as y axis
127 | const my = battlers.length
128 | let ry = y < my ? y : abs(y % my)
129 | ry = ry < 0 ? my - 1 : ry
130 | const b = battlers[ry]
131 |
132 | // select skill as x axis
133 | const mx = b.skills.length
134 | let rx = x < mx ? x : abs(x % mx)
135 | rx = rx < 0 ? mx - 1 : rx
136 | console.log(x, y, rx, ry)
137 | return {
138 | x: rx,
139 | y: ry
140 | }
141 | }
142 |
--------------------------------------------------------------------------------
/src/client/sagas/battleSaga.js:
--------------------------------------------------------------------------------
1 | /* @flow */
2 | import uuid from 'uuid'
3 | import { delay } from 'redux-saga'
4 | import { sync } from '../actions/battleSagaActions'
5 | import * as battleActions from '../actions/battleActions'
6 | import type { BattleSession } from 'domain/battle'
7 | import type { AdventureSession } from 'domain/adventure/AdventureSession'
8 | import {
9 | isBattleFinished,
10 | processTurn,
11 | buildBattleSession
12 | } from 'domain/battle'
13 | import { call, put, race, take, takeEvery } from 'redux-saga/effects'
14 | import * as CommandResultActions from 'domain/battle/CommandResult'
15 | import type { Input, Battler, Skill } from 'domain/battle'
16 |
17 | let _inputQueue: Input[] = []
18 |
19 | function hydrateInputQueue() {
20 | const iq = _inputQueue
21 | _inputQueue = []
22 | return iq
23 | }
24 |
25 | function* addInputToQueue(action: any) {
26 | if (waitMode) {
27 | // Can't intercept
28 | return
29 | }
30 | _inputQueue = _inputQueue.concat([{ ...action.payload, id: uuid('input') }])
31 | yield put(battleActions.updateInputQueue(_inputQueue))
32 | }
33 |
34 | export function findActiveSkill(battlers: Battler[]): ?Skill {
35 | for (const b of battlers) {
36 | if (b.controllable) {
37 | const executableSkill = b.skills.find(
38 | sk => sk.cooldown.val >= sk.cooldown.max
39 | )
40 | if (executableSkill) {
41 | return executableSkill
42 | }
43 | }
44 | }
45 | return
46 | }
47 |
48 | let waitMode = false
49 | function* start(action: { payload: { adventureSession: AdventureSession } }) {
50 | // Use wait mode
51 | waitMode = location.search.indexOf('wait') > -1
52 |
53 | // let session: BattleSession = createBattleSession()
54 | // debugger
55 | let session: BattleSession = buildBattleSession(
56 | action.payload.adventureSession
57 | )
58 |
59 | // Sync first
60 | yield put(sync(session))
61 |
62 | // Start loop
63 | while (true) {
64 | // InputQueue buffer
65 | let takenInputQueue: Input[] = []
66 |
67 | // WaitMode: check executableSkill
68 | if (waitMode) {
69 | // Wait input on wait mode
70 | const executableSkill = findActiveSkill(session.battlers)
71 | if (executableSkill) {
72 | yield put(sync(session))
73 | yield put(battleActions.paused())
74 | const takenInputAction: { payload: Input } = yield take(
75 | battleActions.ADD_INPUT_TO_QUEUE
76 | )
77 | takenInputQueue = [takenInputAction.payload]
78 | yield put(battleActions.restarted())
79 | yield call(delay, 100)
80 | }
81 | }
82 |
83 | // ActiveMode: wait interval or intercept by pause request
84 | if (!waitMode) {
85 | // const { paused, waited } = yield race({
86 | const { paused } = yield race({
87 | waited: call(delay, 300),
88 | paused: take(battleActions.REQUEST_PAUSE)
89 | })
90 | // if user request pausing, wait for restart
91 | if (paused) {
92 | yield put(battleActions.paused())
93 | yield take(battleActions.REQUEST_RESTART)
94 | yield put(battleActions.restarted())
95 | }
96 | // Get input
97 | takenInputQueue = hydrateInputQueue()
98 | yield put(battleActions.updateInputQueue([]))
99 | }
100 |
101 | // Update session
102 | const processed = processTurn(session, takenInputQueue)
103 | session = processed.session
104 | for (const result of processed.commandResults) {
105 | switch (result.type) {
106 | case CommandResultActions.LOG:
107 | yield put(battleActions.log(result.message))
108 | if (waitMode) {
109 | yield put(sync(session))
110 | yield call(delay, 100)
111 | }
112 | break
113 | }
114 | }
115 |
116 | // Check finished flag
117 | const result = isBattleFinished(session)
118 | if (result) {
119 | yield put(sync(session))
120 | yield put(battleActions.openBattleSessionResult(result))
121 | // yield put(battleActions.openBattleSessionResult(`${finshed.winner} win.`))
122 | yield take(battleActions.EXIT_BATTLE_SESSION)
123 | return
124 | // break
125 | }
126 |
127 | // Sync session by each frame on active
128 | if (!waitMode) {
129 | yield put(sync(session))
130 | }
131 |
132 | // Clear inputQueue
133 | takenInputQueue = []
134 | }
135 | }
136 |
137 | export default function* battleSaga(): any {
138 | yield takeEvery(battleActions.REQUEST_START, start)
139 | yield takeEvery(battleActions.ADD_INPUT_TO_QUEUE, addInputToQueue)
140 | }
141 |
--------------------------------------------------------------------------------
/flow-typed/npm/recompose_v0.21.x.js:
--------------------------------------------------------------------------------
1 | declare module 'recompose' {
2 |
3 | /*
4 | Fn1 = Function with arity of 1
5 | HOC = Higher order component
6 | SCU = Should component update function
7 | */
8 |
9 | declare type FunctionComponent = (props: A) => ?React$Element;
10 |
11 | declare type ClassComponent = Class>;
12 |
13 | declare type Component = FunctionComponent | ClassComponent;
14 |
15 | declare type Fn1 = (a: A) => B;
16 |
17 | declare type HOC = Fn1, Component>;
18 |
19 | declare type SCU = (props: A, nextProps: A) => boolean;
20 |
21 | declare function id(a: A): A;
22 | declare function compose(pq: Fn1, op: Fn1, mo: Fn1, lm: Fn1, kl: Fn1, jk: Fn1, ij: Fn1, hi: Fn1, gh: Fn1, fg: Fn1, ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1;
23 | declare function compose(op: Fn1, mo: Fn1, lm: Fn1, kl: Fn1, jk: Fn1, ij: Fn1, hi: Fn1, gh: Fn1, fg: Fn1, ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1;
24 | declare function compose(mo: Fn1, lm: Fn1, kl: Fn1, jk: Fn1, ij: Fn1, hi: Fn1, gh: Fn1, fg: Fn1, ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1;
25 | declare function compose(lm: Fn1, kl: Fn1, jk: Fn1, ij: Fn1, hi: Fn1, gh: Fn1, fg: Fn1, ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1;
26 | declare function compose(kl: Fn1, jk: Fn1, ij: Fn1, hi: Fn1, gh: Fn1, fg: Fn1, ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1;
27 | declare function compose(jk: Fn1, ij: Fn1, hi: Fn1, gh: Fn1, fg: Fn1, ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1;
28 | declare function compose(ij: Fn1, hi: Fn1, gh: Fn1, fg: Fn1, ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1;
29 | declare function compose(hi: Fn1, gh: Fn1, fg: Fn1, ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1;
30 | declare function compose(gh: Fn1, fg: Fn1, ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1;
31 | declare function compose(fg: Fn1, ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1;
32 | declare function compose(ef: Fn1, de: Fn1, cd: Fn1, bc: Fn1, ab: Fn1, ...rest: Array): Fn1