public void Test_FalseValue()
{
var falseValue = Bool.False();
var isCalled = false;
falseValue.When(() => Abort(), () => { isCalled = true; });
Assert.True(isCalled);
var one = falseValue.When(() => 0, () => 1);
Assert.Equal(1, one);
var t = falseValue.Bind(_ => {
Abort();
return(Bool.False());
});
Assert.Throws <InvalidOperationException>(
() => Polluter.Pollute(t)
);
var t2 = falseValue.Fmap(_ => {
Abort();
return(false);
});
Assert.Throws <InvalidOperationException>(
() => Polluter.Pollute(t2)
);
}
public void Test_TrueValue()
{
var trueValue = Bool.True();
var isCalled = false;
trueValue.When(() => { isCalled = true; }, () => Abort());
Assert.True(isCalled);
var one = trueValue.When(() => 1, () => 0);
Assert.Equal(1, one);
var t = trueValue.Bind(_ => {
Assert.True(_);
return(Bool.False());
});
Assert.False(Polluter.Pollute(t));
var t2 = trueValue.Fmap(_ => {
Assert.True(_);
return(false);
});
Assert.False(Polluter.Pollute(t2));
}
public void Test_TrueFunction()
{
// Boolを返却する関数をしていする。
// 関数はこのタイミングで即時に評価される。
var trueValue = Bool.Return(() => true);
var isCalled = false;
trueValue.When(() => { isCalled = true; }, () => Abort());
Assert.True(isCalled);
var one = trueValue.When(() => 1, () => 0);
Assert.Equal(1, one);
var t = trueValue.Bind(_ => {
Assert.True(_);
return(Bool.False());
});
Assert.False(Polluter.Pollute(t));
var t2 = trueValue.Fmap(_ => {
Assert.True(_);
return(false);
});
Assert.False(Polluter.Pollute(t2));
}
public void Test_Nothhing()
{
var nothing = Optional.Nothing <int>();
nothing.Bind(o => {
Abort();
return(Optional.Nothing <int>());
});
nothing.Fmap(o => {
Abort();
return(1);
});
nothing.Map(o => {
Abort();
return(1);
});
nothing.IfPresent(
_ => Abort(),
() => {}
);
nothing.IfPresent(
_ => Abort(),
() => {});
Assert.Equal(1, nothing.OrElse(1));
Assert.Throws <InvalidOperationException>(
() => Polluter.Pollute(nothing)
);
}
private void AddTimedInstance(Polluter p, float time)
{
NoiseSplat noiseSplat = new NoiseSplat(p, time + Time.time);
p.SetSplat(noiseSplat);
removeTime.Add(new Pair <float, NoiseSplat>(time + Time.time, noiseSplat));
}
public void Test_TrueValue()
{
var trueValue = BoolLazy.True();
var isCalled = false;
// Bool.When().Else()で分岐
trueValue.When(() => { isCalled = true; }, () => Abort());
Assert.True(isCalled);
// Bool.When(then:, elseThen:)で分岐。一時変数を作らない分こちらの方がパフォーマンスは良いはず。
var one = trueValue.When(() => 1, () => 0);
Assert.Equal(1, one);
// Bindは別のIMonadを返却できる
var t = trueValue.Bind(_ => {
Assert.True(_);
return(Bool.False());
});
Assert.False(Polluter.Pollute(t));
// Fmapは別のBoolLazyを返却できる
var t2 = trueValue.Fmap(_ => {
Assert.True(_);
return(false);
});
Assert.False(Polluter.Pollute(t2));
}
/// <summary>
///
/// </summary>
public static Optional <T> Do <T>(this Optional <T> self, Action <T> action)
{
if (self.HasValue)
{
action(Polluter.Pollute(self));
}
return(self);
}
/// <summary>
/// left `action` right
/// </summary>
public static Optional <W> Apply <U, V, W>(Optional <U> left, Optional <V> right, Func <U, V, W> action)
{
if (!left.HasValue || !right.HasValue)
{
return(Optional <W> .Nothing);
}
return(Optional <W> .Just(action(Polluter.Pollute(left), Polluter.Pollute(right))));
}
public void Test_Awaitor1()
{
// 単一Task
var state = MaybeTask.From(DummyTask(10));
var result = state.Awaitor.Result;
Assert.True(result.HasValue);
Assert.Equal(10, Polluter.Pollute(result));
}
private bool CanRemove(Polluter polluter)
{
if (polluter.GetOwnerID() == stateManager.GetCurrentPlayerID() &&
polluter.GetAttrib().economicAttrib.removalCost <= stateManager.GetCurrentPlayerState().GetMoney())
{
return(true);
}
return(false);
}
public void PlayTimedOnceOff(Vector2 pos, int dB, int radius, string name, GameObject go, float time = 1f)
{
if (dB > 0 && radius > 0 && time > 0f)
{
Polluter polluter = GetPolluter(radius);
polluter.SetAttributes(pos, dB, go, name);
AddTimedInstance(polluter, time);
}
}
private void FreePolluter(Polluter pol)
{
if (pol != null)
{
pol.Clear();
Debug.Assert(inusePool[pol.radius].Contains(pol));
inusePool[pol.radius].Remove(pol);
freePool[pol.radius].Add(pol);
}
}
public NoiseSplat CreateNoiseSplat(Vector2 pos, int dB, int radius, string name, GameObject go)
{
Polluter polluter = GetPolluter(radius);
polluter.SetAttributes(pos, dB, go, name);
NoiseSplat noiseSplat = new NoiseSplat(polluter, 0f);
polluter.SetSplat(noiseSplat);
return(noiseSplat);
}
private bool CheckPolluter(GameObject targetGameObject)
{
bool hasFoundData = false;
Polluter polluter = targetGameObject.GetComponentInChildren <Polluter>();
if (polluter != null)
{
hasFoundData = true;
PolluterAttrib attrib = polluter.GetAttrib();
polluterContent.textTitle.text = attrib.title;
polluterContent.textDetails.text = "Price: " + attrib.economicAttrib.price + " Income: " + attrib.economicAttrib.profitPerTurn + "\nRemoval cost: " + attrib.economicAttrib.removalCost;
VulnerabilityAttrib vulnerabilityAttrib = attrib.vulnerabilityAttrib;
if (vulnerabilityAttrib.vulnerabilities != null)
{
string vulnerabilityString = "Vulnerable to ";
foreach (VulnerabilityAttrib.Vulnerability v in vulnerabilityAttrib.vulnerabilities)
{
vulnerabilityString += v.disasterName + ":" + v.factor + " ";
}
polluterContent.textVulnerabilities.text = vulnerabilityString;
}
else
{
polluterContent.textVulnerabilities.text = "";
}
PollutionMap map = new PollutionMap(attrib.pollutionAttrib.emissions);
if (polluter is Filter)
{
map = Util.MultiplyMap(map, (-1));
}
VisualAttrib visualAttrib = attrib.visualAttrib;
if (visualAttrib.imageName != "")
{
worldWindow.imageLoader.LoadImage(visualAttrib.imageName);
imageToShow = true;
}
else
{
imageToShow = false;
}
imageIsDisaster = !polluter.IsAlive();
SetPieChart(polluterContent.pieChart, map);
}
return(hasFoundData);
}
public void Test_Awaitor2()
{
// 2つのTaskを直列化
var state = MaybeTask
.From(DummyTask(10))
.Map(DummyTask(15));
var result = state.Awaitor.Result;
Assert.True(result.HasValue);
Assert.Equal(10, Polluter.Pollute(result).Item1);
Assert.Equal(15, Polluter.Pollute(result).Item2);
}
public void AddPolluter(Polluter polluter)
{
Debug.Assert(!HasPolluter(polluter));
polluters.Add(polluter);
var mapChangeEvent = polluter.GetPollutionMapChangeEvent();
mapChangeEvent.AddListener(() =>
{
stateChangeEventMap[PollutionMapType.PRODUCED].Invoke();
stateChangeEventMap[PollutionMapType.FILTERED].Invoke();
});
}
void Start()
{
attribLoader = UIManager.Instance.attribLoader;
playerController = UIManager.Instance.playerController;
var data = attribLoader.LoadLazy();
ShowFactories();
var factoryAttribs = purchasables[0].polluterAttribs;
foreach (var factoryAttrib in data.factoryList)
{
factoryAttribs.Add(factoryAttrib);
}
var filterAttribs = purchasables[1].polluterAttribs;
foreach (var filterAttrib in data.filterList)
{
filterAttribs.Add(filterAttrib);
}
foreach (var pur in purchasables)
{
for (int i = 0; i < pur.polluterAttribs.Count; i++)
{
PurchasableIcon purchasableIcon = null;
Polluter polluter = pur.purchasableIcon.GetPolluterIcon().GetPolluter();
if (polluter is Factory)
{
purchasableIcon = Instantiate(pur.purchasableIcon, factoriesMenu);
purchasableIcon.SetSpace(spaceFactories);
}
if (polluter is Filter)
{
purchasableIcon = Instantiate(pur.purchasableIcon, filtersMenu);
purchasableIcon.SetSpace(spaceFilters);
}
purchasableIcon.SetPolluterAttributes(pur.polluterAttribs[i]);
purchasableIcon.playerController = playerController;
purchasableIcon.shopTransform = transform;
purchasableIcon.polluterId = (i + 1);
purchasableIcon.SetText(purchasableIcon.polluterId.ToString());
}
}
}
public GameObject InstantiatePolluter()
{
GameObject g = Instantiate(targetPolluter.gameObject, spaceForPolluter.transform);
Polluter p = g.GetComponentInChildren <Polluter>();
p.SetAttrib(polluterAttrib);
p.polluterId = polluterId;
polluterDragged = p;
gameObjectDragged = g;
return(g);
}
public void Test_Fmap()
{
var maybe1 = Optional.Just(1);
var maybe2 = maybe1.Fmap(o => o + 1);
Assert.Equal(2, Polluter.Pollute(maybe2));
var m2o = (Optional <int>)maybe2;
m2o.IfPresent(o => Assert.Equal(2, o), () => Abort());
var maybeString = maybe1.Fmap(_ => "text");
Assert.Equal("text", Polluter.Pollute(maybeString));
}
public void Test_Awaitor3_Flat()
{
// 3つのTaskを直列化
// 結果は自身で定義する。
var state = MaybeTask
.From(DummyTask(10))
.Map(async prev => (await DummyTask(15)).Map(next => (prev, next)))
.Map(async prev => (await DummyTask(20)).Map(next => (prev.Item1, prev.Item2, next)));
var result = state.Awaitor.Result;
Assert.True(result.HasValue);
Assert.Equal(10, Polluter.Pollute(result).Item1);
Assert.Equal(15, Polluter.Pollute(result).Item2);
Assert.Equal(20, Polluter.Pollute(result).Item3);
}
public void Test_Awaitor3()
{
// 3つのTaskを直列化。
// 結果はTuple<Tuple<1, 2>, 3>
var state = MaybeTask
.From(DummyTask(10))
.Map(DummyTask(15))
.Map(DummyTask(20));
var result = state.Awaitor.Result;
Assert.True(result.HasValue);
Assert.Equal(10, Polluter.Pollute(result).Item1.Item1);
Assert.Equal(15, Polluter.Pollute(result).Item1.Item2);
Assert.Equal(20, Polluter.Pollute(result).Item2);
}
public void Test_Awaitor3_Flat2()
{
// 3つのTaskを直列化
// 結果は自身で定義する。
// Maybe a -> (a -> Task<Maybe (a b)>) -> Maybe (a b)は実装がわかりにくいので自動化
// Maybe a -> (a -> Task<(a Maybe b)>) -> (a Maybe b)とならないように。
var state = MaybeTask
.From(DummyTask(10))
.Map(prev => DummyTask(15), (prev, next) => Optional.Just((prev, next)))
.Map(prev => DummyTask(20), (prev, next) => Optional.Just((prev.Item1, prev.Item2, next)));
var result = state.Awaitor.Result;
Assert.True(result.HasValue);
Assert.Equal(10, Polluter.Pollute(result).Item1);
Assert.Equal(15, Polluter.Pollute(result).Item2);
Assert.Equal(20, Polluter.Pollute(result).Item3);
}
public void Test_TrueFunction()
{
var once = true;
// boolを返却する関数を元に生成する。
// 関数の評価は次のWhenなどまで遅延される。
var trueValue = BoolLazy.Return(() => {
if (!once)
{
Abort();
}
once = false;
return(true);
});
var isCalled = false;
trueValue.When(() => { isCalled = true; }, () => Abort());
Assert.True(isCalled);
var one = trueValue.When(() => 1, () => 0);
Assert.Equal(1, one);
var t = trueValue.Bind(_ => {
Assert.True(_);
return(Bool.False());
});
Assert.False(Polluter.Pollute(t));
var t2 = trueValue.Fmap(_ => {
Assert.True(_);
return(false);
});
Assert.False(Polluter.Pollute(t2));
}
private Polluter GetPolluter(int radius)
{
Polluter polluter = null;
if (!freePool.ContainsKey(radius))
{
freePool.Add(radius, new List <Polluter>());
}
if (freePool[radius].Count > 0)
{
polluter = freePool[radius][0];
freePool[radius].RemoveAt(0);
}
else
{
polluter = new Polluter(radius);
}
if (!inusePool.ContainsKey(radius))
{
inusePool.Add(radius, new List <Polluter>());
}
inusePool[radius].Add(polluter);
return(polluter);
}
public void RemovePolluter(Polluter polluter)
{
polluters.Remove(polluter);
stateChangeEventMap[PollutionMapType.PRODUCED].Invoke();
stateChangeEventMap[PollutionMapType.FILTERED].Invoke();
}
public void Test_Right()
{
var right = Either <bool, int> .Right(1);
var isCalled = false;
right.IfRight(_ =>
{
Assert.Equal(1, _);
isCalled = true;
},
_ => Abort());
Assert.True(isCalled);
isCalled = false;
right.IfLeft(
_ => Abort(),
_ =>
{
Assert.Equal(1, _);
isCalled = true;
});
Assert.True(isCalled);
isCalled = false;
right.IfRight(_ =>
{
Assert.Equal(1, _);
isCalled = true;
}, _ => Abort());
Assert.True(isCalled);
isCalled = false;
right.IfLeft(_ => Abort(),
_ =>
{
Assert.Equal(1, _);
isCalled = true;
});
Assert.True(isCalled);
var o = right.IfRight(_ =>
{
Assert.Equal(1, _);
return(1);
}
, _ => 0);
Assert.Equal(1, o);
o = right.IfLeft(
_ => 0,
_ =>
{
Assert.Equal(1, _);
return(1);
});
Assert.Equal(1, o);
o = right.IfRight(_ =>
{
Assert.Equal(1, _);
return(1);
}, _ => 0);
Assert.Equal(1, o);
o = right.IfLeft(_ => 0,
_ =>
{
Assert.Equal(1, _);
return(1);
});
Assert.Equal(1, o);
var z = right.Bind(_ => { return(Either <float, int> .Right(0)); });
Assert.Equal(0, Polluter.Pollute(z));
var o2 = right.Fmap(_ => { return(1); });
Assert.Equal(1, Polluter.Pollute(o2));
var o3 = right.Map(_ => { return(1); });
Assert.Equal(1, Polluter.Pollute(o3).PolluteRight());
}
public bool HasPolluter(Polluter polluter)
{
return(polluters.Contains(polluter));
}
/// <summary> /// Maybeのリストから値を持つもののリストへ変換 /// </summary> /// <typeparam name="U"></typeparam> /// <param name="list"></param> /// <returns></returns> public static IEnumerable <U> MapPollute <U>(IEnumerable <Optional <U> > list) => (from x in list where x.HasValue select Polluter.Pollute(x));
public Polluter CopyAssign(Polluter rhs)
{
polluterAttrib = rhs.polluterAttrib;
ownerID = rhs.ownerID;
return(this);
}
public void SetPolluter(Polluter polluter)
{
this.polluter = polluter;
OperatePolluter();
}
