sc2 0.2.0

organelle networks for StarCraft II Client API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103


use organelle;
use organelle::{ Sheath, ResultExt, Neuron, Impulse, Dendrite };

use super::{
    Result, Axon, Signal, Synapse, Race, Difficulty, PlayerSetup
};

/// soma that acts as the built-in SC2 AI
pub enum ComputerSoma {
    /// initialize the axon
    Init(Init),
    /// respond to the setup queries
    Setup(Setup),
}

impl ComputerSoma {
    /// create a new computer soma
    pub fn sheath(race: Race, difficulty: Difficulty) -> Result<Sheath<Self>> {
        Ok(
            Sheath::new(
                ComputerSoma::Init(
                    Init {
                        setup: PlayerSetup::Computer {
                            race: race,
                            difficulty: difficulty,
                        },
                    }
                ),
                vec![
                    Dendrite::RequireOne(Synapse::Controller),
                    Dendrite::RequireOne(Synapse::InstanceProvider),
                ],
                vec![ ],
            )?
        )
    }
}

impl Neuron for ComputerSoma {
    type Signal = Signal;
    type Synapse = Synapse;

    fn update(self, axon: &Axon, msg: Impulse<Signal, Synapse>)
        -> organelle::Result<Self>
    {
        match self {
            ComputerSoma::Init(state) => state.update(axon, msg),
            ComputerSoma::Setup(state) => state.update(axon, msg),
        }.chain_err(
            || organelle::ErrorKind::SomaError
        )
    }
}

pub struct Init {
    setup:          PlayerSetup,
}

impl Init {
    fn update(self, _axon: &Axon, msg: Impulse<Signal, Synapse>)
        -> Result<ComputerSoma>
    {
        match msg {
            Impulse::Start => Setup::setup(self.setup),


            Impulse::Signal(_, msg) => {
                bail!("unexpected message {:#?}", msg)
            },
            _ => bail!("unexpected protocol message")
        }
    }
}

pub struct Setup {
    setup:          PlayerSetup,
}

impl Setup {
    fn setup(setup: PlayerSetup) -> Result<ComputerSoma> {
        Ok(ComputerSoma::Setup(Setup { setup: setup }))
    }

    fn update(self, axon: &Axon, msg: Impulse<Signal, Synapse>)
        -> Result<ComputerSoma>
    {
        match msg {
            Impulse::Signal(_, Signal::RequestPlayerSetup(_)) => {
                axon.send_req_input(
                    Synapse::Controller, Signal::PlayerSetup(self.setup)
                )?;

                Ok(ComputerSoma::Setup(self))
            },

            Impulse::Signal(_, msg) => {
                bail!("unexpected message {:#?}", msg)
            },
            _ => bail!("unexpected protocol message")
        }
    }
}