public EtcsBrakingData()
{
Input = new InputData();
Middle = new MiddleData();
Output = new OutputData();
Params = new ConstantData();
}
static void Main(string[] args)
{
string line;
System.IO.StreamReader file =
new System.IO.StreamReader(@"D:\input\input1.txt");
List<InputData> aInputList = new List<InputData>();
ShiftManager aManager = new ShiftManager();
while ((line = file.ReadLine()) != null)
{
InputData aData = new InputData();
string[] input = line.Split(' ');
aData.BSC = input[0];
aData.BCF = input[1];
aData.BTS = input[2];
aData.TRX = input[3];
aData.PCM = input[4];
aData.PCMTsl = input[5];
aData.LAPDName = input[6];
aData.LAPDTSL = input[7];
aData.LAPDSSL = input[8];
aInputList.Add(aData);
}
aManager.TRXshifter(aInputList);
}
// Update is called once per frame
void Update()
{
// 종료 처리
if (Input.GetKey(KeyCode.Escape)
|| Input.GetKey(KeyCode.Home)
|| Input.GetKey(KeyCode.Menu))
{
//Application.Quit();
SendMessage("ApplicationQuit");
}
// 터치
if (Input.GetMouseButtonDown(0))
{
InputData kInputData = new InputData();
kInputData.nTouchCount = Input.touchCount;
kInputData.tmTouchPosition.Add(0, Input.mousePosition);
SendMessage("InputTouch", kInputData, SendMessageOptions.RequireReceiver);
}
if (Input.GetKeyDown(KeyCode.X))
{
SendMessage("KeyDownDefend");
}
}
public ThermalСalculationPage()
{
InitializeComponent();
_inputData = MainWindow.DrawInputData(InputDataGrid, ReportKind.Thermal);
App.CurrentEngineType = EngineType.Petrol;
MainWindow.UpdateInputData(InputDataGrid, App.CurrentEngineType, _inputData);
}
public void PushesInput()
{
TimeSpan loopDuration = TimeSpan.FromMilliseconds(IterationMilliseconds);
var c = new SimulationDAQController(loopDuration) { Clock = new FakeClock() };
IOutputData expectedOutput;
DAQOutputStream outStream;
DAQInputStream inStream;
SetupInputPipeline(c, out expectedOutput, out outStream, out inStream);
c.SimulationRunner = (IDictionary<IDAQOutputStream, IOutputData> output, TimeSpan timeStep) =>
{
var inputData = new Dictionary<IDAQInputStream, IInputData>(1);
expectedOutput = output[outStream];
inputData[inStream] = new InputData(expectedOutput.Data, expectedOutput.SampleRate, DateTimeOffset.Now);
return inputData;
};
c.ProcessIteration += (controller, evtArgs) => ((IDAQController)controller).Stop();
bool stopped = false;
c.Stopped += (controller, evtArgs) =>
{
stopped = true;
};
c.Start(false);
Thread.Sleep(500);
var actualInput = ((TestDevice)outStream.Device).InputData.ContainsKey(inStream) ? ((TestDevice)outStream.Device).InputData[inStream].First() : null;
Assert.That(actualInput, Is.Not.Null);
Assert.That(actualInput.Data, Is.EqualTo(expectedOutput.Data));
}
public void ShouldBitShiftAndMaskPushedInputData()
{
Converters.Clear();
var controller = new NIDAQController();
var s = new NIDigitalDAQInputStream("IN", controller);
controller.SampleRate = new Measurement(10000, 1, "Hz");
TimeSpan duration = TimeSpan.FromSeconds(0.5);
var devices = new List<TestDevice>();
for (ushort bitPosition = 1; bitPosition < 32; bitPosition += 2)
{
TestDevice dev = new TestDevice();
dev.BindStream(s);
s.BitPositions[dev] = bitPosition;
devices.Add(dev);
}
var data = new InputData(Enumerable.Range(0, 10000).Select(i => new Measurement((short)(i % 2 * 0xaaaa), Measurement.UNITLESS)).ToList(),
s.SampleRate, DateTime.Now);
s.PushInputData(data);
s.PushInputData(data);
var expected = Enumerable.Range(0, 10000).Select(i => new Measurement(i % 2, Measurement.UNITLESS)).ToList();
foreach (var ed in devices)
{
Assert.AreEqual(expected, ed.InputData[s].ElementAt(0).Data);
Assert.AreEqual(expected, ed.InputData[s].ElementAt(1).Data);
}
}
public ReporterWindow(InputData data, ReportKind reportKind)
{
InitializeComponent();
_inputData = data;
_currentRepot = CurrentDataReport.OutputDataReport;
_reportKind = reportKind;
}
public bool Serialize(InputData data)
{
// 기존 데이터를 클리어합니다.
Clear();
// 각 요소를 차례로 시리얼라이즈합니다.
bool ret = true;
ret &= Serialize(data.count);
ret &= Serialize(data.flag);
MouseSerializer mouse = new MouseSerializer();
for (int i = 0; i < data.datum.Length; ++i) {
mouse.Clear();
bool ans = mouse.Serialize(data.datum[i]);
if (ans == false) {
return false;
}
byte[] buffer = mouse.GetSerializedData();
ret &= Serialize(buffer, buffer.Length);
}
return ret;
}
FSharpOption<MatchResult> MatchSingleQuoteString(InputData data) {
if(data.Head.Value == "'") {
var sourceLocation = data.Head.Source;
var sb = new StringBuilder();
data = data.Tail;
while(true) {
if(data.IsEmpty) {
throw new UnexpectedEndOfFileException();
}
if(data.Head.Value == "'") {
var next = data.Tail;
if(next.IsCons && next.Head.Value == "'") {
sb.Append("'");
data = next.Tail;
}
else {
var token = new Token.StringValue(sourceLocation, new Token.StringValue.StringPart(sb.ToString()));
return MatchToken(token, data.Tail);
}
}
else {
sb.Append(data.Head.Value);
data = data.Tail;
}
}
}
else {
return FSharpOption<MatchResult>.None;
}
}
void Start()
{
if (Application.loadedLevel == SceneName.Title.ToInt()){
act = transform.root.GetComponent<SceneLoadManager>().NextScene;
}
SoundManager.obj.PlayBGM(2,true);
decIcons = 0;
length = transform.childCount;
childObj = new GameObject[length];
for(int i=0;i<length;i++){
childObj[i] = transform.GetChild(i).gameObject;
if(childObj[i] == null) continue;
if(iconCount == null) iconCount = childObj[i].GetComponent<IconCount>();
if(childObj[i].tag != decTexture) continue;
decImage = childObj[i].GetComponent<Image>();
decTrans = decImage.rectTransform;
decTrans.localScale = Vector2.zero;
}
playMax = 0;
PlayerNum = 4;
input = new InputData[PlayerNum];
for(int i = 0;i<PlayerNum;i++){
input[i] = new InputData();
InputPad.InputData(ref input[i], i+1);
}
}
void Start()
{
touchManager = GetComponent<TouchManager>();
for (int i = 0; i < input.Length; i++) {
input[i] = new InputData();
}
}
private static float Sine(InputData d)
{
return 0.50f +
// 0.25f * Mathf.Sin(4 * Mathf.PI * p.x + 4 * t) * Mathf.Sin(2 * Mathf.PI * p.z + t) +
// 0.10f * Mathf.Cos(3 * Mathf.PI * p.x + 5 * t) * Mathf.Cos(5 * Mathf.PI * p.z + 3 *t) +
// 0.15f * Mathf.Sin(Mathf.PI * p.x + 0.6f * t);
Mathf.Sin(d.p.x*10 +d.t*5) *.1f + Mathf.Sin(d.p.z*10+d.t*5) *.1f;
}
// Update is called once per frame
void Update()
{
foreach( AbstractInputDevice device in myInputDevices)
{
device.HandleInput();
// TODO: Sort through all of the input controllers and determine what the state of input should be...
myCurrentInputData = device.Data;
}
}
void Start()
{
GameDataObj = GameObject.Find ("GameDataObject") as GameObject;
scorenum = GameDataObj.GetComponent<GameData> ().score;
difficulty = GameDataObj.GetComponent<GameData> ().difficulty;
GameDataObj.GetComponent<GameData> ().AlignScore (scorenum,difficulty);
score.text = "Score:" + scorenum.ToString();
indata = GameObject.Find ("Indata") as GameObject;
indatacomp = indata.GetComponent<InputData> ();
}
private void DrawListElement(Rect rect, InputData data)
{
EditorGUI.BeginChangeCheck();
GUI.Toggle(rect, data.m_Selected, EditorGUIUtility.TempContent(data.m_Name), s_Styles.menuItem);
if (EditorGUI.EndChangeCheck())
{
this.m_Callback(data);
base.Close();
}
}
//[SerializeField]
//GameObject Background;
// Use this for initialization
void Start()
{
GameDataObj = GameObject.Find ("GameDataObject") as GameObject;
dotscale = GameDataObj.GetComponent<GameData> ().dotscale;
transform.localScale = new Vector3(dotscale, dotscale, dotscale);
MainSpriteRenderer = gameObject.GetComponent<SpriteRenderer>();
tmpInfected = false;
Infected = false;
indata = GameObject.Find ("Indata") as GameObject;
indatacomp = indata.GetComponent<InputData> ();
}
public OutputData GetOutputData(InputData inputData)
{
var result = new OutputData
{
Servers = inputData.Servers
};
// TODO: add some logic here
return result;
}
private static string _currentlyOpenedFile = "Untitled.mml"; // Открытый в данный момент файл
/// <summary>
/// Функция SaveFile(InputData inpDObj)
///
/// Сохраняет объект в файл. Введенные пользователем данные, сформированные в объект
/// сохраняются в JSON формате
/// </summary>
/// <param name="inpDObj"></param>
public async static Task SaveFile(InputData inpDObj)
{
if (inpDObj == null) return; // Если поступил null объект, выходим из функции
if (_currentlyOpenedFile != "Untitled.mml") // Если был открыт файл, перезаписываем в него
{
await OutputObjectToFile(inpDObj, _currentlyOpenedFile); // Выводим объект в этот файл
}
else // Если нет, то
{
await SaveAsFile(inpDObj); // Действуем по аналогии с SaveAs
}
}
void Start()
{
if (Application.loadedLevel == SceneName.Title.ToInt()){
act = transform.root.GetComponent<SceneLoadManager>().NextScene;
}
PlayerNum = 4;
SoundManager.obj.PlayBGM(3,true);
for(int i=0;i<PlayerNum;i++){
input[i] = new InputData();
InputPad.InputData(ref input[i], i+1);
}
}
public void CreateAction()
{
var test = CSScript.CreateAction(@"using Tests;
void Test(InputData data)
{
data.Index = 7;
}");
var data = new InputData();
test(data);
Assert.Equal(7, data.Index);
}
// Use this for initialization
void Start()
{
E = GameObject.Find ("EASY") as GameObject;
N = GameObject.Find ("NORMAL") as GameObject;
H = GameObject.Find ("HARD") as GameObject;
D = GameObject.Find ("GameDataObject") as GameObject;
R = GameObject.Find ("RSELECT") as GameObject;
L = GameObject.Find ("LSELECT") as GameObject;
D.GetComponent<GameData> ().SetDifficulty (1);
indata = GameObject.Find ("Indata") as GameObject;
indatacomp = indata.GetComponent<InputData> ();
}
void setRemoteInput(InputData input)
{
if (input.Accelerate!=null)
character.Accelerate((float)input.Accelerate);
if (input.Strafe!=null)
character.Strafe((float)input.Strafe);
if (input.Rotate!=null)
character.Rotate((float)input.Rotate);
if (input.Jump!=null)
character.Jump((bool)input.Jump);
if (input.Position!=null)
character.gameObject.transform.position = (Vector3)input.Position;
}
public void LoadMethodStatic()
{
var Test = CSScript.LoadMethod(@"using Tests;
static void Test(InputData data)
{
data.Index = 7;
}")
.GetStaticMethodWithArgs("*.Test", typeof(InputData));
var data = new InputData();
Test(data);
Assert.Equal(7, data.Index);
}
/// <summary>
/// Функция SaveFile(InputData inpDObj)
///
/// Сохраняет объект в файл, предложив окно сохранения. Введенные пользователем данные, сформированные в объект
/// сохраняются в JSON формате
/// </summary>
/// <param name="inpDObj"></param>
public async static Task SaveAsFile(InputData inpDObj)
{
var sdg = new Microsoft.Win32.SaveFileDialog // Создаем диалоговое окно сохранения
{
FileName = "Document", // Имя файла по умолчанию
DefaultExt = ".mml", // Расширение файла по умолчанию
Filter = "MM Data (.mml)|*.mml" // Фильтр расширений файла
};
var result = sdg.ShowDialog(); // Открывает диалоговое окно сохранения
if (result != true) return; // Обрабатываем результат выполнения диалогового окна сохранения
var filename = sdg.FileName; // Получаем имя файла, введенное пользователем
await OutputObjectToFile(inpDObj, filename); // Записываем объект в файл
_currentlyOpenedFile = filename; // Сохраняем имя файла
}
public static bool ParAndValidations2(InputData data,
Validation[] validators) {
IAsyncResult[] ars = new IAsyncResult[validators.Length];
for (int i = 0; i < validators.Length; ++i) {
ars[i] = validators[i].BeginInvoke(data, null, null);
}
bool result = true;
for (int i = 0; i < validators.Length; ++i) {
result &= validators[i].EndInvoke(ars[i]);
}
return result;
}
public void CompileMethodStatic()
{
CSScript.EvaluatorConfig.Engine = EvaluatorEngine.Roslyn;
var script = CSScript.RoslynEvaluator
.CompileMethod(@"using Tests;
static void Test(InputData data)
{
data.Index = 7;
}");
InputData data = new InputData();
var Test = script.GetStaticMethod("*.Test", data);
Test(data);
Assert.Equal(7, data.Index);
}
public static void UpdateInputData(Grid grid, EngineType engine, InputData data)
{
foreach (var child in grid.Children)
if (child is TextBox)
foreach (var key in data.Data.Keys)
if (key == (child as TextBox).Name)
if (data.Data[key].Engine.FindIndex(type => type == engine) < 0)
{
(child as TextBox).IsEnabled = false;
(child as TextBox).Background = Brushes.Gray;
}
else
{
(child as TextBox).IsEnabled = true;
(child as TextBox).Background = Brushes.White;
}
}
public bool Deserialize(byte[] data, ref InputData serialized)
{
// 디시리얼라이즈할 데이터를 설정합니다.
bool ret = SetDeserializedData(data);
if (ret == false) {
return false;
}
// 데이터 요소별로 디시리얼라이즈합니다.
ret &= Deserialize(ref serialized.count);
ret &= Deserialize(ref serialized.flag);
// 디시리얼라이즈 후의 버퍼 크기를 구합니다.
MouseSerializer mouse = new MouseSerializer();
MouseData md = new MouseData();
mouse.Serialize(md);
byte[] buf= mouse.GetSerializedData();
int size = buf.Length;
serialized.datum = new MouseData[serialized.count];
for (int i = 0; i < serialized.count; ++i) {
serialized.datum[i] = new MouseData();
}
for (int i = 0; i < serialized.count; ++i) {
byte[] buffer = new byte[size];
// mouseData의11프레임분의 데이터를 추출합니다.
bool ans = Deserialize(ref buffer, size);
if (ans == false) {
return false;
}
ret &= mouse.Deserialize(buffer, ref md);
if (ret == false) {
return false;
}
serialized.datum[i] = md;
}
return ret;
}
public static bool ParAndValidations1(InputData data, Validation[] validators) {
ManualResetEvent done = new ManualResetEvent(false);
int count = 0;
bool finalResult = true;
foreach (Validation v in validators) {
Validation validator = v;
ThreadPool.QueueUserWorkItem((_) => {
bool res = validator(data);
if (!res)
finalResult = false;
if (Interlocked.Increment(ref count) == validators.Length)
done.Set();
});
}
done.WaitOne();
return finalResult;
}
private void ReadFunc()
{
string input = "";
InputData sendData;
while (true)
{
if (_output != null)
{
input = _output.ReadLine();
}
if (input != "")
{
sendData = new InputData();
sendData.Data = input;
outPut(this, sendData);
}
}
}
private static Texture2D CreateIconWithMipLevels(InputData inputData, string baseName, List <string> assetPathsOfAllIcons, Dictionary <int, Texture2D> mipTextures)
{
List <string> allMipPaths = assetPathsOfAllIcons.FindAll(o => o.IndexOf('/' + baseName + inputData.mipIdentifier, StringComparison.Ordinal) >= 0);
List <Texture2D> allMips = new List <Texture2D>();
foreach (string path in allMipPaths)
{
int mipLevel = MipLevelForAssetPath(path, inputData.mipIdentifier);
Texture2D mip;
if (mipTextures != null && mipTextures.ContainsKey(mipLevel))
{
mip = mipTextures[mipLevel];
}
else
{
mip = GetTexture2D(path);
}
if (mip != null)
{
allMips.Add(mip);
}
else
{
Debug.LogError("Mip not found " + path);
}
}
// Sort the mips by size (largest mip first)
allMips.Sort(delegate(Texture2D first, Texture2D second)
{
if (first.width == second.width)
{
return(0);
}
else if (first.width < second.width)
{
return(1);
}
else
{
return(-1);
}
});
int minResolution = 99999;
int maxResolution = 0;
foreach (Texture2D mip in allMips)
{
int width = mip.width;
if (width > maxResolution)
{
maxResolution = width;
}
if (width < minResolution)
{
minResolution = width;
}
}
if (maxResolution == 0)
{
return(null);
}
// Create our icon
Texture2D iconWithMips = new Texture2D(maxResolution, maxResolution, TextureFormat.RGBA32, true, false);
// Add max mip
if (BlitMip(iconWithMips, allMips, 0))
{
iconWithMips.Apply(true);
}
else
{
return(iconWithMips); // ERROR
}
// Keep for debugging
//Debug.Log ("Processing max mip file: " + inputData.GetMipFileName (baseName, maxResolution) );
// Now add the rest
int resolution = maxResolution;
for (int i = 1; i < iconWithMips.mipmapCount; i++)
{
resolution /= 2;
if (resolution < minResolution)
{
break;
}
BlitMip(iconWithMips, allMips, i);
}
iconWithMips.Apply(false, true);
return(iconWithMips);
}
// 수신.
public void ReceiveInputData()
{
byte[] data = new byte[1400];
// 데이터를 송신합니다.
int recvSize = m_transport.Receive(ref data, data.Length);
if (recvSize < 0)
{
// 입력정보를 수신하지 않았으므로 다음 프레임을 처리할 수 없습니다.
return;
}
string str = System.Text.Encoding.UTF8.GetString(data);
if (requestData.CompareTo(str.Trim('\0')) == 0)
{
// 접속 요청 패킷 .
return;
}
// byte 배열을 구조체로 변환합니다.
InputData inputData = new InputData();
InputSerializer serializer = new InputSerializer();
serializer.Deserialize(data, ref inputData);
// 수신한 입력 정보를 설정합니다.
PlayerInfo info = PlayerInfo.GetInstance();
int playerId = info.GetPlayerId();
int opponent = (playerId == 0)? 1 : 0;
for (int i = 0; i < inputData.count; ++i)
{
int frame = inputData.datum[i].frame;
//Debug.Log("Set inputdata"+i+"[" + recvFrame + "][" + frame + "]:" + (recvFrame + 1 == frame));
if (recvFrame + 1 == frame)
{
inputBuffer[opponent].Add(inputData.datum[i]);
++recvFrame;
}
}
//Debug.Log("recvFrame:" + recvFrame);
// 접속 종료 플래그를 감시. bit1:접속 종료 응답, bit0: 접속 종료 요구.
if ((inputData.flag & 0x03) == 0x03)
{
// 접속 종료 플래그 수신.
suspendSync = 0x03;
Debug.Log("Receive SuspendSync.");
}
if ((inputData.flag & 1) > 0 && (suspendSync & 1) > 0)
{
suspendSync |= 0x02;
Debug.Log("Receive SuspendSync." + inputData.flag);
}
if (isConnected && suspendSync == 0x03)
{
// 서로 접속 종료 상태가 되었으므로 상대에게의 접속 종료 플래그를 보내기위한.
// 유예기간을 두고 조금 후에 접속종료합니다.
++disconnectCount;
if (disconnectCount > 10)
{
m_transport.Disconnect();
Debug.Log("Disconnect because of suspendSync.");
}
}
// 상태 갱신.
if (syncState == SyncState.NotStarted)
{
syncState = SyncState.WaitSynchronize;
}
//loopCounter = 0;
}
public ImageDescriptionViewModel(InputData data, byte[] image)
{
_data = data;
ByteArray = image;
}
public override string ToString()
{
return(InputData.ToString());
}
static void Start(string[] args)
{
InputData inputData = IoHandler.GetParameters(args);
IParser parser = new Parser(inputData);
GaSettings settings = parser.ParseSettings();
Ga algorithm;
switch (settings.Type)
{
case AlgorithmType.Generation:
algorithm = new GenerationGa(parser);
break;
case AlgorithmType.Elimination:
algorithm = new EliminationGa(parser);
break;
default:
throw new ArgumentOutOfRangeException();
}
Genome bestSolution = algorithm.Start();
Console.WriteLine("\n____________Proces is finished____________\n");
if (bestSolution != null)
{
Console.Write("Best result is: " + bestSolution.Fitness + ", with parameters: ");
PrintParameters(bestSolution.Genes);
}
Console.WriteLine("\n____________Classification____________\n");
algorithm.Test(out double[][] givenClasses, out double[][] expectedOutput);
bool[] correct = new bool[expectedOutput.Length];
for (int i = 0; i < expectedOutput.Length; i++)
{
correct[i] = true;
Console.Write("Expected classes: ");
for (int j = 0; j < expectedOutput[i].Length; j++)
{
Console.Write(expectedOutput[i][j].ToString("G0") + " ");
}
Console.Write("\tGiven classes: ");
for (int j = 0; j < givenClasses[i].Length; j++)
{
Console.Write(givenClasses[i][j].ToString("G0") + " ");
if (!(Math.Abs(expectedOutput[i][j] - givenClasses[i][j]) < double.Epsilon))
{
correct[i] = false;
}
}
Console.WriteLine(correct[i] ? "\tCorrect classification." : "\tIncorrect classification.");
}
int correctlyClassified = 0;
int incorrectlyClassified = 0;
for (int i = 0; i < correct.Length; i++)
{
if (correct[i])
{
correctlyClassified++;
}
else
{
incorrectlyClassified++;
}
}
Console.WriteLine("Correctly classified samples: " + correctlyClassified + ", incorrectly classified: " + incorrectlyClassified);
}
public List <ChargePoint> Process(CoreReferenceData coreRefData)
{
this.ImportRefData = new CommonImportRefData(coreRefData);
//whole file cleanup (broken newline in text)
InputData = InputData.Replace("\n\";", "\";");
var results = InputData.Split('\n');
var keyLookup = results[0].Replace("\r", "").Split(';').ToList();
List <ChargePoint> outputList = new List <ChargePoint>();
int rowIndex = 0;
foreach (var row in results)
{
//skip first row or empty rows
if (rowIndex > 0 && !String.IsNullOrEmpty(row))
{
if (!(String.IsNullOrEmpty(row.Replace(";", "").Trim())))
{
var cols = row.Replace("\r", "").Replace(";", " ;").Split(';');
var poi = new ChargePoint();
var title = cols[keyLookup.FindIndex(a => a == "DESIGNACIÓ-DESCRIPTIVA")];
var usageType = cols[keyLookup.FindIndex(a => a == "ACCES")];
var operatorName = cols[keyLookup.FindIndex(a => a == "PROMOTOR-GESTOR")];
var speed = cols[keyLookup.FindIndex(a => a == "TIPUS VELOCITAT")];
var connectionType = cols[keyLookup.FindIndex(a => a == "TIPUS CONNEXIÓ")];
var latitude = cols[keyLookup.FindIndex(a => a == "LATITUD")];
var longitude = cols[keyLookup.FindIndex(a => a == "LONGITUD")];
var reference = cols[keyLookup.FindIndex(a => a == "IDE PDR")];
var address = cols[keyLookup.FindIndex(a => a == "ADREÇA")];
var province = cols[keyLookup.FindIndex(a => a == "PROVINCIA")];
var city = cols[keyLookup.FindIndex(a => a == "MUNICIPI")];
var numStations = cols[keyLookup.FindIndex(a => a == "NPLACES ESTACIÓ")];
var vehicleTypes = cols[keyLookup.FindIndex(a => a == "TIPUS VEHICLE")];
var telephone = cols[keyLookup.FindIndex(a => a == "TELEFON")];
var hours = cols[keyLookup.FindIndex(a => a == "HORARI")];
var additionalInfo = cols[keyLookup.FindIndex(a => a == "INFORMACIÓ ADICIONAL")];
poi.DataProviderID = DataProviderID;
poi.DataProvidersReference = reference;
poi.AddressInfo = new AddressInfo();
poi.AddressInfo.Title = title;
poi.AddressInfo.AddressLine1 = address.Trim();
poi.AddressInfo.Town = city;
if (city != province)
{
poi.AddressInfo.StateOrProvince = province;
}
poi.AddressInfo.Latitude = double.Parse(latitude);
poi.AddressInfo.Longitude = double.Parse(longitude);
poi.AddressInfo.ContactTelephone1 = telephone;
poi.AddressInfo.AccessComments = hours;
poi.GeneralComments = additionalInfo;
//TODO: Operator and Operators Reference
if (usageType.StartsWith("VIA PUBLICA"))
{
usageType = "VIA PUBLICA";
}
//resolve usage type
switch (usageType.Trim())
{
case "APARCAMENT PUBLIC":
case "VIA PUBLICA":
case "VIA PUBLICA -VORERA":
poi.UsageType = ImportRefData.UsageType_Public;
break;
case "APARCAMENT CC":
poi.UsageType = ImportRefData.UsageType_PublicPayAtLocation;
break;
default:
Log("Unknown Usage Type: " + usageType);
break;
}
//parse equipment info
var stations = numStations.Split('+');
if (String.IsNullOrWhiteSpace(numStations))
{
stations = new string[] { "1" }
}
; //blank, default to 1
var connectionTypes = connectionType.Split('+');
foreach (var c in connectionTypes)
{
if (poi.Connections == null)
{
poi.Connections = new List <ConnectionInfo>();
}
var connection = new ConnectionInfo();
//connection.Quantity = int.Parse(ns.Trim());
switch (c.ToLower().Trim())
{
case "chademo":
connection.ConnectionTypeID = (int)StandardConnectionTypes.CHAdeMO;
break;
case "mennekes":
case "mennekes.m":
connection.ConnectionTypeID = (int)StandardConnectionTypes.MennekesType2;
break;
case "schuko":
case "mennekes.f":
connection.ConnectionTypeID = (int)StandardConnectionTypes.Schuko;
break;
case "ccs combo2":
connection.ConnectionTypeID = (int)StandardConnectionTypes.CCSComboType2;
break;
case "j1772":
connection.ConnectionTypeID = (int)StandardConnectionTypes.J1772;
break;
default:
Log("Unknown Connection Type: " + c);
break;
}
poi.StatusTypeID = (int)StandardStatusTypes.Operational;
//level/status
switch (speed.Trim())
{
case "NORMAL":
case "semiRAPID i NORMAL": //low quality description, default to lowest spec
case "semiRAPID":
connection.LevelID = 2;
connection.Voltage = 220;
connection.Amps = 32;
connection.PowerKW = (connection.Voltage * connection.Amps) / 1000;
connection.CurrentTypeID = (int)StandardCurrentTypes.SinglePhaseAC;
connection.StatusTypeID = (int)StandardStatusTypes.Operational;
break;
case "RAPID":
case "superRAPID":
connection.LevelID = 3;
connection.Voltage = 400;
connection.Amps = 100;
connection.PowerKW = (connection.Voltage * connection.Amps) / 1000;
connection.CurrentTypeID = (int)StandardCurrentTypes.DC;
connection.StatusTypeID = (int)StandardStatusTypes.Operational;
break;
case "FORA DE SERVEI":
connection.StatusTypeID = (int)StandardStatusTypes.NotOperational;
poi.StatusTypeID = (int)StandardStatusTypes.NotOperational;
break;
case "DESMANTELLADA":
connection.StatusTypeID = (int)StandardStatusTypes.RemovedDecomissioned;
poi.StatusTypeID = (int)StandardStatusTypes.RemovedDecomissioned;
break;
default:
Log("Unknown Speed Type: " + speed);
break;
}
poi.Connections.Add(connection);
}
//vehicle type metadata:
poi.MetadataValues = new List <MetadataValue>();
if (vehicleTypes.Contains("cotxe"))
{
poi.MetadataValues.Add(new MetadataValue {
MetadataFieldID = (int)StandardMetadataFields.VehicleType, MetadataFieldOptionID = (int)StandardMetadataFieldOptions.Car
});
}
if (vehicleTypes.Contains("moto"))
{
poi.MetadataValues.Add(new MetadataValue {
MetadataFieldID = (int)StandardMetadataFields.VehicleType, MetadataFieldOptionID = (int)StandardMetadataFieldOptions.Motorbike
});
}
if (vehicleTypes.Contains("mercaderies"))
{
poi.MetadataValues.Add(new MetadataValue {
MetadataFieldID = (int)StandardMetadataFields.VehicleType, MetadataFieldOptionID = (int)StandardMetadataFieldOptions.DeliveryVehicle
});
}
//TODO: get status of first equipment item and use that as status for overall poi
if (poi.DataQualityLevel == null)
{
poi.DataQualityLevel = 2;
}
poi.SubmissionStatus = ImportRefData.SubmissionStatus_Imported;
outputList.Add(poi);
}
}
rowIndex++;
}
return(outputList);
}
}
internal TheoristFunction(InputData inSampleData, DateTime startTime, EstimationFunctionType estFunctionType, Account acc, StratergyParameterRange range)
: base(inSampleData, startTime, estFunctionType, acc, range)
{
}
void Awake()
{
im = GetComponent <InputManager>();
data = new InputData(im.axisCount, im.buttonCount);
}
public static bool IsTypeValid(InputData _input, OutputData _output)
{
return((_input != null && _output != null) && (_input.Type == _output.Type || (_input.Type == ANY && _output.Type != GENERIC) || (_input.Type != GENERIC && _output.Type == ANY) || (_input.Type != ANY && _output.Type == GENERIC) || (_input.Type == GENERIC && _output.Type != ANY)));
}
public abstract void ReadInput(InputData data);
//入力
public void AddInput(InputData input)
{
//_inputNumber = input.number;
AddBullet(input);
}
void Awake()
{
Data = new InputData();
}
protected override void BuildRenderTree(RenderTreeBuilder builder)
{
var seq = 0;
builder.OpenElement(seq, "figure");
builder.AddAttribute(++seq, "class", "line-chart");
builder.OpenElement(++seq, "div");
builder.AddAttribute(++seq, "class", "main");
System.Diagnostics.Debug.WriteLine("ID" + InputData);
string[] inputDataArrX = InputData.Split(new char[] { '[', ']' }, StringSplitOptions.RemoveEmptyEntries);
string[] inputLabelsArr = InputLabels.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
int numLines = 0;
System.Diagnostics.Debug.WriteLine("Start");
foreach (string inputLine in inputDataArrX)
{
if (inputLine.IndexOfAny(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }) >= 0)
{
numLines++;
}
}
System.Diagnostics.Debug.WriteLine("End");
string[] inputDataArr = new string[numLines];
int lineCounter = 0;
foreach (string inputLine in inputDataArrX)
{
if (inputLine.IndexOfAny(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }) >= 0)
{
inputDataArr[lineCounter++] = inputLine;
System.Diagnostics.Debug.WriteLine("IL:" + inputLine);
}
}
string[] colors = { "#ce4b99", "#27A844", "#377bbc" };
string[] labels = { "App Store", "Website", "Partners" };
double boundHeight = 150.0;
double boundWidth = 150.0;
SVG svg = new SVG()
{
{ "width", "100%" }, { "height", "100%" }, { "viewBox", "0 0 150 150" }
};
//Rectangle rect = new Rectangle() { { "class", "background-rect" }, { "width", "100%" }, { "height", "100%" }, { "fill", "white" }, { "stroke", "gray" }, {"stroke-width", "0.5" } };
//Rectangle rect = new Rectangle() { { "width", "100%" }, { "height", "100%" }, { "fill", "cyan" }};
Rectangle rect = new Rectangle()
{
{ "class", "background-rect" }
};
svg.AddItems(rect);
int numHorizontalLines = 10;
int numVerticalLines = 10;
double verticalStartSpace = 25.0;
double horizontalStartSpace = 25.0;
double verticalEndSpace = 25.0;
double horizontalEndSpace = 25.0;
double gridYUnits = 10;
double gridXUnits = 10;
//bool skipLastVerticalLine = true;
//bool skipLastHorizontalLine = true;
double verticalSpace = (boundHeight - verticalStartSpace - verticalEndSpace) / (numHorizontalLines);
double horizontalSpace = (boundWidth - horizontalStartSpace - horizontalEndSpace) / (numVerticalLines);
double totalGridWidth = ((double)(numVerticalLines - 1)) * horizontalSpace;
double totalGridHeight = ((double)(numHorizontalLines - 1)) * verticalSpace;
System.Diagnostics.Debug.WriteLine("TotalGridHeight:" + totalGridHeight + ":" + verticalSpace);
//Horizontal Lines
double y = verticalStartSpace;
double startGridY = 0;
for (int counter = 0; counter <= numHorizontalLines; counter++)
{
//if (counter == numHorizontalLines - 1 && skipLastHorizontalLine)
// continue;
Path path = new Path()
{
{ "class", "horizontal-grid-lines" }, { "d", "M " + horizontalStartSpace.ToString() + " " + (boundHeight - y).ToString() + " L " + (boundWidth - horizontalEndSpace).ToString() + " " + (boundHeight - y).ToString() }
};
Text label = new Text()
{
{ "class", "y-axis-labels" }, { "x", (horizontalStartSpace - 2).ToString() }, { "y", (boundHeight - y).ToString() }, { "content", (startGridY).ToString() }
};
svg.AddItems(path, label);
System.Diagnostics.Debug.WriteLine("Y:" + y);
y = y + verticalSpace;
startGridY = startGridY + gridYUnits;
}
//Chart Line
double gridx = 0, gridy = 0;
gridx = horizontalStartSpace;
gridy = boundHeight - verticalStartSpace;
int colorcounter = 0;
foreach (string iData in inputDataArr)
{
string chartLine = "";
double gridValueX = 0;
double gridValueY = 0;
bool firstTime = true;
string[] inputLineArr = iData.Split(',');
int[] intAry = new int[inputLineArr.Length];
for (int i = 0; i < inputLineArr.Length; i++)
{
intAry[i] = int.Parse(inputLineArr[i]);
}
foreach (int i in intAry)
{
if (firstTime)
{
chartLine = chartLine + "M ";
firstTime = false;
gridValueX = horizontalStartSpace;
gridValueY = verticalStartSpace;
double gridValue = ((double)i) * verticalSpace / gridYUnits;
gridValueY = boundHeight - (gridValueY + gridValue);
chartLine = chartLine + gridValueX.ToString() + " " + gridValueY.ToString();
}
else
{
chartLine = chartLine + " L ";
gridValueX = gridValueX + horizontalSpace;
gridValueY = verticalStartSpace;
double gridValue = ((double)i) * verticalSpace / gridYUnits;
gridValueY = boundHeight - (gridValueY + gridValue);
chartLine = chartLine + gridValueX.ToString() + " " + gridValueY.ToString();
}
}
//System.Diagnostics.Debug.WriteLine("CL:" + chartLine);
// Path linepath = new Path() { { "fill", "none" }, { "stroke", colors[colorcounter++] }, { "stroke-width", "1.0" }, { "d", chartLine } };
Path linepath = new Path()
{
{ "class", "line-" + (colorcounter + 1).ToString() }, { "d", chartLine }
};
colorcounter++;
svg.AddItems(linepath);
}
//Vertical Lines
double x = horizontalStartSpace;
double startGridX = 0;
for (int counter = 0; counter <= numVerticalLines; counter++)
{
//if (counter == numVerticalLines - 1 && skipLastVerticalLine)
// continue;
Path path = new Path()
{
{ "class", "vertical-grid-lines" }, { "d", "M " + x.ToString() + " " + (boundHeight - verticalStartSpace).ToString() + " L " + x.ToString() + " " + (verticalEndSpace).ToString() }
};
Text label = new Text()
{
{ "class", "x-axis-labels" }, { "x", x.ToString() }, { "y", (boundHeight - verticalStartSpace + 5).ToString() }, { "content", (startGridX).ToString() }
};
startGridX = startGridX + gridXUnits;
svg.AddItems(path, label);
x = x + horizontalSpace;
}
BlazorRenderer blazorRenderer = new BlazorRenderer();
blazorRenderer.Draw(seq, builder, svg);
builder.OpenElement(++seq, "figcaption");
builder.AddAttribute(++seq, "class", "key");
builder.OpenElement(++seq, "ul");
builder.AddAttribute(++seq, "class", "key-list");
//builder.AddAttribute(++seq, "aria-hidden", "true");
//builder.AddAttribute(++seq, "style", "list-style-type: none;");
colorcounter = 0;
foreach (string iData in inputDataArr)
{
//int data = int.Parse(dataStr);
builder.OpenElement(++seq, "li");
builder.OpenElement(++seq, "span");
builder.AddAttribute(++seq, "class", "legend-" + (colorcounter + 1).ToString());
//builder.AddAttribute(++seq, "style", "background-color:" + colors[colorcounter]);
builder.CloseElement();
string label = "";
if (colorcounter < inputLabelsArr.Length)
{
label = inputLabelsArr[colorcounter];
}
builder.AddContent(++seq, label);
builder.CloseElement();
colorcounter++;
}
builder.CloseElement();
builder.CloseElement();
builder.CloseElement();
builder.CloseElement();
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// receives InputData when a gamepad/keyboard/mouse input is pressed
/// </summary>
///////////////////////////////////////////////////////////////////////////////////////////////
void Pressed(InputData _data)
{
//your code here
}
public void Detect()
{
double[] input = null;
double scale = 0;
double tuning = 0;
if (InputData.GetType().Name == "Double[]")
{
input = (double[])InputData;
}
if (InputArgs.ContainsKey("SCALE"))
{
if (InputArgs["SCALE"].GetType().Name == "Double")
{
scale = (double)InputArgs["SCALE"];
}
}
if (InputArgs.ContainsKey("TUNING"))
{
if (InputArgs["TUNING"].GetType().Name == "Double")
{
tuning = (double)InputArgs["TUNING"];
}
}
if (input == null || scale == 0)
{
return;
}
Dictionary <double, double> output = new Dictionary <double, double>();
double spectAvg = input.Average();
double spectMax = input.Max();
int notesPerOctave = 12;
double minFreq = double.Parse(Settings["MIN_FREQ"][0]) + (tuning * double.Parse(Settings["MIN_FREQ"][0]) / 100);
double[] noteFreqs = new double[notesPerOctave * int.Parse(Settings["OCTAVES"][0])];
for (int i = 0; i < noteFreqs.Length; i++)
{
noteFreqs[i] = minFreq * Math.Pow(2, (double)i / notesPerOctave);
}
double prevMag = 0;
double prevFreq = 0;
for (int i = 0; i < noteFreqs.Length; i++)
{
int inputIndex = (int)Math.Round(noteFreqs[i] * scale) - 1;
int clusterSize = 0;
while (clusterSize / scale <= noteFreqs[i] / 100 * double.Parse(Settings["FREQ_TOLERANCE"][0]))
{
clusterSize++;
}
if (inputIndex + clusterSize > input.Length)
{
break;
}
double avgMag = 0;
double maxVal = 0, maxIndex = 0;
for (int j = -clusterSize; j < clusterSize; j++)
{
avgMag += input[inputIndex + j];
if (input[inputIndex + j] > maxVal)
{
maxVal = input[inputIndex + j];
maxIndex = inputIndex + j;
}
}
avgMag /= 2 * clusterSize + 1;
double maxFreq = maxIndex / scale;
if (Math.Abs(prevMag - maxVal) > Math.Max(prevMag, maxVal) / 4 && noteFreqs[i] < 200)
{
if (prevMag - maxVal < 0)
{
output.Remove(prevFreq);
}
else
{
prevMag = maxVal;
prevFreq = maxFreq;
continue;
}
}
if (avgMag > spectAvg + ((spectMax - spectAvg) * double.Parse(Settings["MAG_THRESHOLD"][0])))
{
output[maxFreq] = maxVal;
}
prevMag = maxVal;
prevFreq = maxFreq;
//Console.WriteLine("Note Freq: " + noteFreqs[i] + " Cluster Size: " + clusterSize + " Max Freq: " + (maxIndex / scale) + " Max Mag: " + maxVal);
}
output = output.OrderByDescending(x => x.Value).ToDictionary(x => x.Key, x => x.Value);
Output = output.Take(int.Parse(Settings["MAX_VALS"][0])).ToDictionary(pair => pair.Key, pair => pair.Value);
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// receives InputData when a gamepad/keyboard/mouse input is held
/// </summary>
///////////////////////////////////////////////////////////////////////////////////////////////
void Held(InputData _data)
{
//your code here
timeHeld += Time.deltaTime;
Debug.Log("Player 1 is charging up their fireball! (" + timeHeld + ")");
}
/// <inheritdoc />
public bool GetValue(InputData data)
{
Assert.Ref(data);
return(data.GetKeyDown(code));
}
void Start()
{
_pInputData = PlayerInput.Instance.Data;
_styleFont = Resources.Load <Font> (@"Fonts/CASCADIA");
}
private static SpecificState GetNextState(SpecificState currentState, InputData currentInput, PhysicalData currentPhysicals, float deadzone = float.Epsilon)
{
var nextState = currentState;
switch (currentState)
{
case SpecificState.IdleLeft:
if (currentInput.horizontal > deadzone)
{
nextState = SpecificState.IdleRight;
}
else if (currentInput.horizontal < -deadzone)
{
nextState = SpecificState.RunLeft;
}
else if (currentPhysicals.velocity.y < -deadzone)
{
nextState = SpecificState.FallFaceLeft;
}
else if (currentInput.buttonA)
{
nextState = SpecificState.JumpFaceLeft;
}
break;
case SpecificState.IdleRight:
if (currentInput.horizontal > deadzone)
{
nextState = SpecificState.RunRight;
}
else if (currentInput.horizontal < -deadzone)
{
nextState = SpecificState.IdleLeft;
}
else if (currentPhysicals.velocity.y < -deadzone)
{
nextState = SpecificState.FallFaceLeft;
}
else if (currentInput.buttonA)
{
nextState = SpecificState.JumpFaceRight;
}
break;
case SpecificState.RunLeft:
if (currentInput.horizontal > -deadzone)
{
nextState = SpecificState.IdleLeft;
}
else if (currentPhysicals.velocity.y < -deadzone)
{
nextState = SpecificState.FallMoveLeft;
}
else if (currentInput.buttonA)
{
nextState = SpecificState.JumpMoveLeft;
}
else if (currentPhysicals.leftWall)
{
nextState = SpecificState.ClimbLeftIdle;
}
break;
case SpecificState.RunRight:
if (currentInput.horizontal < deadzone)
{
nextState = SpecificState.IdleRight;
}
else if (currentPhysicals.velocity.y < -deadzone)
{
nextState = SpecificState.FallMoveRight;
}
else if (currentInput.buttonA)
{
nextState = SpecificState.JumpMoveRight;
}
else if (currentPhysicals.rightWall)
{
nextState = SpecificState.ClimbRightIdle;
}
break;
case SpecificState.JumpFaceLeft:
if (currentPhysicals.velocity.y < -deadzone)
{
nextState = SpecificState.FallFaceLeft;
}
else if (currentInput.horizontal < -deadzone)
{
nextState = SpecificState.JumpMoveLeft;
}
else if (currentInput.horizontal > deadzone)
{
nextState = SpecificState.JumpFaceRight;
}
else if (currentPhysicals.botWall)
{
nextState = SpecificState.IdleLeft;
}
else if (currentPhysicals.topWall && currentInput.vertical > deadzone)
{
nextState = SpecificState.ClimbTopIdleLeft;
}
break;
case SpecificState.JumpFaceRight:
if (currentPhysicals.velocity.y < -deadzone)
{
nextState = SpecificState.FallFaceRight;
}
else if (currentInput.horizontal > deadzone)
{
nextState = SpecificState.JumpMoveRight;
}
else if (currentInput.horizontal < -deadzone)
{
nextState = SpecificState.JumpFaceLeft;
}
else if (currentPhysicals.botWall)
{
nextState = SpecificState.IdleRight;
}
else if (currentPhysicals.topWall && currentInput.vertical > deadzone)
{
nextState = SpecificState.ClimbTopIdleRight;
}
break;
case SpecificState.JumpMoveLeft:
if (currentPhysicals.velocity.y < -deadzone)
{
nextState = SpecificState.FallMoveLeft;
}
else if (currentInput.horizontal > -deadzone)
{
nextState = SpecificState.JumpFaceLeft;
}
else if (currentPhysicals.botWall)
{
nextState = SpecificState.RunLeft;
}
else if (currentPhysicals.leftWall)
{
nextState = SpecificState.ClimbLeftIdle;
}
else if (currentPhysicals.topWall && currentInput.vertical > deadzone)
{
nextState = SpecificState.ClimbTopMoveLeft;
}
break;
case SpecificState.JumpMoveRight:
if (currentPhysicals.velocity.y < -deadzone)
{
nextState = SpecificState.FallMoveRight;
}
else if (currentInput.horizontal < deadzone)
{
nextState = SpecificState.JumpFaceRight;
}
else if (currentPhysicals.botWall)
{
nextState = SpecificState.RunRight;
}
else if (currentPhysicals.rightWall)
{
nextState = SpecificState.ClimbRightIdle;
}
else if (currentPhysicals.topWall && currentInput.vertical > deadzone)
{
nextState = SpecificState.ClimbTopMoveRight;
}
break;
case SpecificState.FallFaceLeft:
if (currentPhysicals.botWall)
{
nextState = SpecificState.IdleLeft;
}
else if (currentInput.horizontal < -deadzone)
{
nextState = SpecificState.FallMoveLeft;
}
else if (currentInput.horizontal > deadzone)
{
nextState = SpecificState.FallFaceRight;
}
break;
case SpecificState.FallFaceRight:
if (currentPhysicals.botWall)
{
nextState = SpecificState.IdleRight;
}
else if (currentInput.horizontal > deadzone)
{
nextState = SpecificState.FallMoveRight;
}
else if (currentInput.horizontal < -deadzone)
{
nextState = SpecificState.FallFaceLeft;
}
break;
case SpecificState.FallMoveLeft:
if (currentPhysicals.botWall)
{
nextState = SpecificState.RunLeft;
}
else if (currentInput.horizontal > -deadzone)
{
nextState = SpecificState.FallFaceLeft;
}
else if (currentPhysicals.leftWall)
{
nextState = SpecificState.ClimbLeftIdle;
}
break;
case SpecificState.FallMoveRight:
if (currentPhysicals.botWall)
{
nextState = SpecificState.RunRight;
}
else if (currentInput.horizontal < deadzone)
{
nextState = SpecificState.FallFaceRight;
}
else if (currentPhysicals.rightWall)
{
nextState = SpecificState.ClimbRightIdle;
}
break;
case SpecificState.ClimbLeftIdle:
if (currentInput.horizontal > -deadzone)
{
nextState = SpecificState.FallFaceLeft;
}
else if (currentInput.vertical > deadzone)
{
nextState = SpecificState.ClimbLeftUp;
}
else if (currentInput.vertical < -deadzone && !currentPhysicals.botWall)
{
nextState = SpecificState.ClimbLeftDown;
}
break;
case SpecificState.ClimbRightIdle:
if (currentInput.horizontal < deadzone)
{
nextState = SpecificState.FallFaceRight;
}
else if (currentInput.vertical > deadzone)
{
nextState = SpecificState.ClimbRightUp;
}
else if (currentInput.vertical < -deadzone && !currentPhysicals.botWall)
{
nextState = SpecificState.ClimbRightDown;
}
break;
case SpecificState.ClimbLeftUp:
if (currentInput.horizontal > -deadzone)
{
nextState = SpecificState.FallFaceLeft;
}
else if (currentInput.vertical < deadzone)
{
nextState = SpecificState.ClimbLeftIdle;
}
else if (!currentPhysicals.leftWall)
{
nextState = SpecificState.FallMoveLeft;
}
else if (currentPhysicals.topWall && currentInput.vertical > deadzone)
{
nextState = SpecificState.ClimbTopIdleLeft;
}
break;
case SpecificState.ClimbRightUp:
if (currentInput.horizontal < deadzone)
{
nextState = SpecificState.FallFaceRight;
}
else if (currentInput.vertical < deadzone)
{
nextState = SpecificState.ClimbRightIdle;
}
else if (!currentPhysicals.rightWall)
{
nextState = SpecificState.FallMoveRight;
}
else if (currentPhysicals.topWall && currentInput.vertical > deadzone)
{
nextState = SpecificState.ClimbTopIdleRight;
}
break;
case SpecificState.ClimbLeftDown:
if (currentInput.horizontal > -deadzone)
{
nextState = SpecificState.FallFaceLeft;
}
else if (currentInput.vertical > -deadzone)
{
nextState = SpecificState.ClimbLeftIdle;
}
else if (!currentPhysicals.leftWall)
{
nextState = SpecificState.FallMoveLeft;
}
else if (currentPhysicals.botWall)
{
nextState = SpecificState.ClimbLeftIdle;
}
break;
case SpecificState.ClimbRightDown:
if (currentInput.horizontal < deadzone)
{
nextState = SpecificState.FallFaceRight;
}
else if (currentInput.vertical > -deadzone)
{
nextState = SpecificState.ClimbRightIdle;
}
else if (!currentPhysicals.rightWall)
{
nextState = SpecificState.FallMoveRight;
}
else if (currentPhysicals.botWall)
{
nextState = SpecificState.ClimbRightIdle;
}
break;
case SpecificState.ClimbTopIdleLeft:
if (currentInput.vertical < deadzone)
{
nextState = SpecificState.FallFaceLeft;
}
else if (currentInput.horizontal < -deadzone && !currentPhysicals.leftWall)
{
nextState = SpecificState.ClimbTopMoveLeft;
}
else if (currentInput.horizontal > deadzone)
{
nextState = SpecificState.ClimbTopIdleRight;
}
break;
case SpecificState.ClimbTopIdleRight:
if (currentInput.vertical < deadzone)
{
nextState = SpecificState.FallFaceRight;
}
else if (currentInput.horizontal > deadzone && !currentPhysicals.rightWall)
{
nextState = SpecificState.ClimbTopMoveRight;
}
else if (currentInput.horizontal < -deadzone)
{
nextState = SpecificState.ClimbTopIdleLeft;
}
break;
case SpecificState.ClimbTopMoveLeft:
if (currentInput.vertical < deadzone)
{
nextState = SpecificState.FallMoveLeft;
}
else if (currentInput.horizontal > -deadzone)
{
nextState = SpecificState.ClimbTopIdleLeft;
}
else if (!currentPhysicals.topWall)
{
nextState = SpecificState.FallMoveLeft;
}
else if (currentPhysicals.leftWall)
{
nextState = SpecificState.ClimbTopIdleLeft;
}
break;
case SpecificState.ClimbTopMoveRight:
if (currentInput.vertical < deadzone)
{
nextState = SpecificState.FallMoveRight;
}
else if (currentInput.horizontal < deadzone)
{
nextState = SpecificState.ClimbTopIdleRight;
}
else if (!currentPhysicals.topWall)
{
nextState = SpecificState.FallMoveRight;
}
else if (currentPhysicals.rightWall)
{
nextState = SpecificState.ClimbTopIdleRight;
}
break;
}
return(nextState);
}
/// <summary>
/// This method adds the data for the right input to the database by calling the AddInput method.
/// </summary>
/// <param name="id"></param>
/// <param name="data"></param>
/// <returns></returns>
public HttpStatusCode AddRightInput(string id, InputData data)
{
_differServiceMethods = new DifferServiceMethods();
return(_differServiceMethods.AddInput(id, data, false));
}
#pragma warning restore 414 // Restore it
void Start()
{
inputData = GetComponent <InputData>();
}
public SampleViewModel6(InputData data)
{
_data = data;
}
public void ParseNotEnoughParametersTest()
{
var sampleFolder = Directory.GetCurrentDirectory();
_ = InputData.Parse(sampleFolder);
}
public OutputData SmartlyTranslate(InputData inputData)
{
return(_SmartTranslationStrategy.RetrieveSmartTranslation(inputData));
}
//down if button pressed this frame, held if button is held, up if button let go off this frame
//button is the input name.
public void InputButton(IInputGenerator inputGenerator, string button, bool held, bool down, bool up)
{
InputData id = new InputData(1.0f, held, down, up);
buffer[inputGenerator.Id][button] = UpdateList(buffer[inputGenerator.Id][button], id);
}
public void PassInput(InputData data)
{
// Debug.Log("Movement: " + data.axes[0] + " , " + data.axes[1]);
_controller.ReadInput(data);
}
private List <Pet> GetPetsByOwnerGender(InputData data, Gender ownerGender)
{
return(data?.ownerAndTheirPets?.Where(x => x.gender == ownerGender && x.pets != null)
?.SelectMany(x => x.pets)
.ToList());
}
private void button2_Click(object sender, EventArgs e)
{
InputData input = new InputData("c:/test.xml");
}
} // end of ParentDepartmentControl
#endregion
//--------------------------------------------------------------------------------------------------
// Events
//--------------------------------------------------------------------------------------------------
#region TriggerStartEvent
/// <summary>
/// State changes of the activities start event. Most state changes are standardized and configurable via input.
/// </summary>
/// <param name="time"> Time of activity start</param>
/// <param name="simEngine"> SimEngine the handles the activity triggering</param>
override public void StateChangeStartEvent(DateTime time, ISimulationEngine simEngine)
{
//--------------------------------------------------------------------------------------------------
// Some activities define the start of corresponding doctor, nurses for future reference
//--------------------------------------------------------------------------------------------------
#region CorrespondingStaff
if (ActionType.DefinesCorrespondingDocStart)
{
Patient.CorrespondingDoctor = ResourceSet.MainDoctor;
ResourceSet.MainDoctor.AddPatient(Patient);
} // end if
if (ActionType.DefinesCorrespondingNurseStart)
{
Patient.CorrespondingNurse = ResourceSet.MainNurse;
ResourceSet.MainNurse.AddPatient(Patient);
} // end if
#endregion
//--------------------------------------------------------------------------------------------------
// If treatment has doctor(s), busyFactors are assigned
//--------------------------------------------------------------------------------------------------
#region AssignBusyFactorsDoctors
if (ResourceSet.MainDoctor != null)
{
ResourceSet.MainDoctor.BusyFactor += ActionType.BusyFactorDoctor;
}
if (ResourceSet.AssistingDoctors != null)
{
if (ResourceSet.AssistingDoctors.Length != ActionType.BusyFactorAssistingDoctors.Length)
{
throw new InvalidOperationException();
}
for (int i = 0; i < ResourceSet.AssistingDoctors.Length; i++)
{
ResourceSet.AssistingDoctors[i].BusyFactor += ActionType.BusyFactorAssistingDoctors[i];
} // end for
} // end if
#endregion
//--------------------------------------------------------------------------------------------------
// If treatment has nurse(s), busyFactors are assigned
//--------------------------------------------------------------------------------------------------
#region AssignBusyFactorsNurses
if (ResourceSet.MainNurse != null)
{
ResourceSet.MainNurse.BusyFactor += ActionType.BusyFactorNurse;
}
if (ResourceSet.AssistingNurses != null)
{
if (ResourceSet.AssistingNurses.Length != ActionType.BusyFactorAssistingNurses.Length)
{
throw new InvalidOperationException();
}
for (int i = 0; i < ResourceSet.AssistingNurses.Length; i++)
{
ResourceSet.AssistingNurses[i].BusyFactor += ActionType.BusyFactorAssistingNurses[i];
} // end for
} // end if
#endregion
//--------------------------------------------------------------------------------------------------
// Preemption
//--------------------------------------------------------------------------------------------------
#region Preemption
// in case the activity was preempted only the remaining duration is considered for scheduling
// the end event
if (DegreeOfCompletion > 0)
{
DateTime endTime = time + Helpers <double> .MultiplyTimeSpan(Duration, (1 - DegreeOfCompletion));
simEngine.AddScheduledEvent(this.EndEvent, endTime);
return;
} // end if
#endregion
//--------------------------------------------------------------------------------------------------
// Occupation
//--------------------------------------------------------------------------------------------------
#region Occupation
// in case of a multiple patient treatment facility the patient
// is added to the holdeld entities
if (ResourceSet.TreatmentFacility is EntityMultiplePatientTreatmentFacility)
{
((EntityMultiplePatientTreatmentFacility)ResourceSet.TreatmentFacility).HoldedEntities.Add(Patient);
}
else
{
//--------------------------------------------------------------------------------------------------
// Set treatmentBooth to occupied
//--------------------------------------------------------------------------------------------------
ResourceSet.TreatmentFacility.Occupied = true;
//--------------------------------------------------------------------------------------------------
// in case patient is blocking the facility required actions are taken
//--------------------------------------------------------------------------------------------------
if (ActionType.DefinesFacilitiyOccupationStart)
{
// facility is blocked for patient
ResourceSet.TreatmentFacility.PatientBlocking = Patient;
// facility is assigned to patient
Patient.OccupiedFacility = ResourceSet.TreatmentFacility;
} // end if
} // end if
#endregion
//--------------------------------------------------------------------------------------------------
// Updating of next Acion and possible skipping of latter
//--------------------------------------------------------------------------------------------------
#region UpdateNextAction
PatientPath.UpdateNextAction();
T nextActionType = PatientPath.GetCurrentActionType();
#endregion
#region PossibleSkipOfNextAction
//--------------------------------------------------------------------------------------------------
// A treatment may be skipped, e.g. in case that the current doctor is qualified enough
// This is defined via the input
//--------------------------------------------------------------------------------------------------
while (ParentDepartmentControl.SkipNextAction(Patient, ResourceSet.MainDoctor, ActionType, PatientPath.GetCurrentActionType()))
{
PatientPath.UpdateNextAction();
nextActionType = PatientPath.GetCurrentActionType();
} // end if
#endregion
//--------------------------------------------------------------------------------------------------
// In case a holding Activity follows no end event is scheduled
//--------------------------------------------------------------------------------------------------
#region HoldingOfPatient
if (ActionType.IsHold)
{
// Staff on hold flag is set to true
foreach (EntityStaff staff in AffectedEntities.Where(p => p is EntityStaff))
{
staff.OnHold = true;
} // end foreach
HoldingRequired = true;
// in case of holding the next action on the path is taken
if (PatientPath.TakeNextAction(simEngine, StartEvent, time, ParentControlUnit))
{
// either waiting or waiting in the treatment facility is launched
if (Patient.OccupiedFacility == null || Patient.OccupiedFacility.ParentDepartmentControl != ParentDepartmentControl)
{
EndEvent.SequentialEvents.Add(Patient.StartWaitingActivity(ParentDepartmentControl.WaitingAreaPatientForNextActionType(nextActionType)));
}
else
{
ActivityWaitInFacility waitInFacility = new ActivityWaitInFacility(ParentControlUnit, Patient, Patient.OccupiedFacility);
EndEvent.SequentialEvents.Add(waitInFacility.StartEvent);
} // end if
} // end if
}
else
{
// if the activity is not hold the end event is scheduled
Duration = InputData.PatientActionTime(Patient,
ResourceSet,
ActionType);
DateTime endTime = time + Duration;
simEngine.AddScheduledEvent(this.EndEvent, endTime);
} // end if
#endregion
} // end of TriggerStartEvent
private InputData GetInputOnPosition(InputPosition position, InputData input, InputData opposingInput)
{
return(input.Position == position ? input : opposingInput);
}
