void Taker <ContentType> .Take(ContentType item)
{
clientColl.Take(item);
parent.local.modifier.SetContent(new AssetContentSettingParam <ContentType> {
content = item, contentPath = path, doOverwrite = true
}, new StubAssetInResultListener <ContentType>());
}
IEnumerator RemoteSPCo(string eWords, Taker <GrammarBlock> listener)
{
inteceptHelper.OnBeginSession(listener);
var form = new WWWForm();
bool didCollect = false;
form.AddBinaryData("ewords", System.Text.Encoding.UTF8.GetBytes(eWords));
UnityWebRequest www = UnityWebRequest.Post(uri, form);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log("HTML_MonoBLProcessor: " + www.error);
}
else
{
Debug.Log(Encoding.UTF8.GetString(www.downloadHandler.data));
var gblock = RequiredFuncs.FromJson <DeserializedGBlock>(www.downloadHandler.data);
listener.Take(gblock);
didCollect = true;
}
inteceptHelper.OnEndSession(listener);
if (!didCollect)
{
listener.None();
}
}
void Taker <GrammarBlock> .Take(GrammarBlock item)
{
ImmediateGiver <GrammarBlock, GrammarBlock> filter = new StdGBlockFilter();
var filteredGBlock = filter.Give(item);
listener.Take(filteredGBlock);
}
void Taker <IEnumerable <BehaverAgent> > .Take(IEnumerable <BehaverAgent> item)
{
foreach (var element in item)
{
parent.agents.Add(element);
parent.spaceInfo.AcceptBehaverAgent(element);
}
taker.Take(item);
}
void Taker <AssetUnitInfo> .Take(AssetUnitInfo newElement)
{
var assetInterface = parent.parent.assetInterface.assetInterface.PickBestElement(newElement);
if (assetInterface != null)
{
auIntefaceTaker.Take(assetInterface);
}
}
void AssetReferenceListener.OnFinish()
{
parent.finishCount++;
if (localAssetInterface != null)
{
if (parent.CheckDependencyAndCollectInterface(localAssetInterface))
{
interfaceTaker.Take(localAssetInterface);
}
}
interfaceTaker.OnFinish();
}
void Giver <IEnumerable <BehaverAgent>, GrammarBlock> .Give(GrammarBlock key, Taker <IEnumerable <BehaverAgent> > colletor)
{
if (GrammarBlockUtils.IsUnit(key, nameOnCreate))
{
var inst = Utilities.ConsistentInstantiate(seekingAgentPrefab);
inst.behaverAttribute = seekingAgentPrefab.behaverAttribute;
inst.gameObject.SetActive(true);
colletor.Take(new List <BehaverAgent> {
inst.behaverAgent
});
}
}
void BasicAssetOut.PickAssetAtPath <ElementType>(string path, Taker <ElementType> collector)
{
try {
var contentFullPath = Path.GetDirectoryName(assetUnitInfo.localref) + "/" + path;
if (typeof(ElementType) == (typeof(ModelImporter)))
{
var importer = (ElementType)(object)ModelImporter.GetAtPath(contentFullPath);
collector.Take(importer);
}
else if (typeof(UnityEngine.Object).IsAssignableFrom(typeof(ElementType)))
{
try {
foreach (var asset in AssetDatabase.LoadAllAssetsAtPath(contentFullPath))
{
try {
var concreteAsset = (ElementType)(object)asset;
if (concreteAsset != null)
{
collector.Take(concreteAsset);
break;
}
} catch { }
}
} catch {
collector.OnFail("StdEditTimeUnityAssetIO.PickAssetAtPath: ");
}
}
else
{
if (File.Exists(contentFullPath))
{
collector.Take(RequiredFuncs.FromJsonAtPath <ElementType>(contentFullPath));
}
}
} catch (Exception e) {
Debug.LogError(e);
}
collector.OnFinish();
}
void AvatarPhysicalizeInterface.Search(GrammarBlock attribute, Taker <IEnumerable <BehaverAgent> > asyncTaker)
{
var pickedAgents = new List <BehaverAgent>();
foreach (var agent in agents)
{
if (agent.MatchAttribue(attribute) == AttributeMatchResult.POSITIVE)
{
pickedAgents.Add(agent);
}
}
asyncTaker.Take(pickedAgents);
}
void MorphemeAnalyzer.AnalyzeFormat(string naturalLanguage, Taker <DivisibleEnumerable <Morpheme> > listener)
{
var result = AnalyzeImmediate(naturalLanguage);
if (result != null)
{
listener.Take(result);
}
else
{
listener.None();
}
}
void Giver<IEnumerable<BehaverAgent>, GrammarBlock>.Give(GrammarBlock key, Taker<IEnumerable<BehaverAgent>> colletor) {
if (GrammarBlockUtils.IsUnit(key, "button")) {
GrammarBlockUtils.ForEachUnits(
key.modifier,
(unit) => {
MonoBBehaverAgent newButton;
nameToButtonDict[unit.word] = newButton = GameObject.Instantiate(textButtonPrefab);
newButton.GetComponent<TextViewer>().SetText(unit.word);
newButton.GetComponent<BehaverAgent>().TryFittingSpace(new Vector3(0.4f, 1f, 1));
colletor.Take(new List<BehaverAgent> { newButton.behaverAgent });
}
);
}
}
void SyntacticProcessor.PerformSyntacticProcess(byte[] behaviorExpression, Taker <GrammarBlock> listener)
{
try {
System.IntPtr marshalArray = Marshal.AllocHGlobal(behaviorExpression.Length);
Marshal.Copy(behaviorExpression, 0, marshalArray, behaviorExpression.Length);
var gBlockPtr = PerformSyntacticProcess(fAnalyser.implPtr, gAnalyser.implPtr, marshalArray, behaviorExpression.Length);
Marshal.FreeHGlobal(marshalArray);
listener.Take(NativeGrammarBlockUtils.GBlockPtrToGBlock(gBlockPtr));
listener.OnFinish();
} catch (Exception e) {
Debug.Log(e);
listener.OnFinish();
}
}
void BehaviorAnalyzer.AnalyzeBehavior(GrammarBlock behaviorExpressionByGBlock, Taker <BehaviorTriggerSet> listener)
{
//ensure behaver
{
var metaDepVis = new MetaInfoDependentGrammarBlockVisitor {
doDeepSeek = true, doDeepSeekModifier = true
};
metaDepVis.metaToVis[StdMetaInfos.nominalBlock.word] = new EnsureBehaver {
behaverGiver = stdGiver
};
GrammarBlockUtils.VisitGrammarBlock(behaviorExpressionByGBlock, metaDepVis);
}
//cereate behavior trigger
{
var rootTrigger = new StdCompositeBehaviorTrigger();
var namedCBTrigger = new Dictionary <string, CompositeBehaviorTrigger>();
var processor = new SentenceBlockRecursiveProcessor {
subSentenceBehaviorTaker = rootTrigger, behaverSetCheck = bSetCheck, namedCBTriggers = namedCBTrigger, support = new StdBehaviorReadySupport {
assetMediator = assetMediator.assetMed
}
};
processor.GrammarBlockCommon(behaviorExpressionByGBlock);
if (rootTrigger.bTriggers.Count > 0 || namedCBTrigger.Count > 0)
{
List <NameAndBTrigger> namedTriggers = null;
if (namedCBTrigger.Count > 0)
{
namedTriggers = new List <NameAndBTrigger>();
foreach (var pair in namedCBTrigger)
{
namedTriggers.Add(new NameAndBTrigger {
name = pair.Key, bTrigger = pair.Value
});
}
}
var result = new BehaviorTriggerSet {
rootTrigger = rootTrigger.bTriggers.Count > 0 ? rootTrigger : null, namedTriggers = namedTriggers
};
listener.Take(result);
}
}
}
public static void DownloadAudio(string url, Taker <AudioClip> taker)
{
var downloadHandler = new DownloadHandlerAudioClip(string.Empty, AudioType.WAV);
downloadHandler.streamAudio = true;
var www = new UnityWebRequest(url, "GET", downloadHandler, null);
ProcessWebRequest(
www,
(www2) => {
var wwwe = www2;
var content = DownloadHandlerAudioClip.GetContent(www);
if (content != null)
{
taker.Take(content);
return;
}
taker.None();
}
);
}
void AssetReferInterface.PickContent <ContentType>(string path, Taker <ContentType> collector)
{
if (typeof(ContentType) == typeof(byte[]))
{
var field = nameAndUIs.Find((item) => string.Compare(item.name, path, true) == 0);
if (field != null)
{
if (!string.IsNullOrEmpty(field.inputField.text))
{
collector.Take((ContentType)(object)System.Text.Encoding.UTF8.GetBytes(field.inputField.text));
return;
} /*else {
* tasks.Add(()=> {
* collector.Take((ContentType)(object)System.Text.Encoding.UTF8.GetBytes(field.inputField.text));
* });
* return;
* }*/
}
}
collector.None();
}
void CheckDependencyAndCollectInterface(AssetUnitInfo assetUnitInfo, Taker <AssetInterface> collector, bool doAddToLocalItfcDbs = false)
{
var customItfc = customAssetInterfaceGiver[AssetUtils.GetPrimalType(assetUnitInfo)];
if (customItfc != null)
{
var localAssetInterface = customItfc.PickBestElement(new StdEditTimeUnityAssetIO {
assetUnitInfo = assetUnitInfo
});
if (doAddToLocalItfcDbs)
{
localizedAssetInfoColl.Take(assetUnitInfo);
}
if (CheckDependencyAndCollectInterface(localAssetInterface))
{
collector.Take(localAssetInterface);
}
}
finishCount++;
collector.OnFinish();
return;
}
void GrammarAnalyzer.AnalyzeGrammar(GAnlysInput input, Taker <GrammarBlock> listener)
{
var result = new ExpansiveMutableGBlock {
metaForCluster = StdMetaInfos.sentenceCluster
};
Action <GrammarBlock> adder = (gBlock) => result.AddBlock(gBlock);
var nextInput = input;
while (true)
{
//prepare
analyzePreparer.Init();
foreach (var morpheme in nextInput.followings)
{
analyzePreparer.FeedMorpheme(morpheme);
if (morpheme.id == 2)
{
break;
}
}
var easyLis = new EasyIncrGAnalysListener {
};
incrGAnalyzer.Analyze(nextInput, easyLis);
if (!easyLis.didMatch)
{
break;
}
nextInput = easyLis.nextInput;
easyLis.listener.OnResultRequested(adder);
}
if (result.content != null)
{
listener.Take(result);
}
else
{
listener.None();
}
}
void AvatarPhysicalizeInterface.Ensure(GrammarBlock attribute, Taker <IEnumerable <BehaverAgent> > taker)
{
bool didCollect = false;
var pickedAgents = new List <BehaverAgent>();
foreach (var agent in agents)
{
if (agent.MatchAttribue(attribute) == AttributeMatchResult.POSITIVE)
{
didCollect = true;
pickedAgents.Add(agent);
}
}
if (pickedAgents.Count > 0)
{
taker.Take(pickedAgents);
}
if (!didCollect)
{
agentFactory.Give(attribute, new PrvColl {
parent = this, taker = taker
});
}
}
void Taker <ContentType> .Take(ContentType item)
{
clientTaker.Take(item);
}
void Taker <AssetInterface> .Take(AssetInterface newElement)
{
success = true;
interfaceTaker.Take(newElement);
}
void ConfigurationListener.OnEnableConfigure <Type>(string name, Taker <Type> collector, Type initialValue)
{
if (typeof(Type) == typeof(bool))
{
bool _initialValue = (bool)(object)initialValue;
var settingContent = GameObject.Instantiate(settingContentPrefab, fieldRootGObj.transform);
settingContent.isOn = _initialValue;
settingContent.onValueChanged.AddListener(new UnityEngine.Events.UnityAction <bool>((toggleValue) => { collector.Take((Type)(object)toggleValue); }));
}
}
void ImmediateMultiGetter <IntPtr> .GetElement(Taker <IntPtr> collector)
{
collector.Take(timeManager.implPtr);
}
void Taker <ItemType> .Take(ItemType item)
{
clientTaker.Take(item);
helper.CountDown();
}
void Taker <AssetType> .Take(AssetType newElement)
{
customzier.implementedAssets.Add(customzier.IntegrateImplementType(newElement, sourceAUInfo, sourceRequest));
externalTaker.Take(newElement);
}
void Taker <GameObject> .Take(GameObject item)
{
coll.Take(item.GetComponent <BaseMonoBType>());
}
void AssetBasicTaker <ContentType> .CollectAsset(ContentType assetType)
{
collector.Take(assetType);
}