// Use this for initialization
protected void Awake()
{
animator = gameObject.GetComponent<Animator>();
UIState = FindObjectOfType<UIStates>();
UISignals = FindObjectOfType<Signals>();
}
public GameController(
Ship ship, AsteroidManager asteroidSpawner,
Signals.ShipCrashed shipCrashedSignal)
{
_shipCrashed = shipCrashedSignal;
_asteroidSpawner = asteroidSpawner;
_ship = ship;
}
void Awake()
{
if (instance != null) {
throw new UnityException("signals already is existing");
} else {
instance = this;
}
}
public AudioHandler(
Signals.ShipCrashed shipCrashed,
AudioSource audioSource,
Settings settings)
{
_settings = settings;
_audioSource = audioSource;
_shipCrashed = shipCrashed;
}
public static void show_Signals(Signals signals)
{
List<ASignal> temp = new List<ASignal>();
foreach (ASignal asignal in signals.data.Values)
{
temp.Add(asignal);
}
show_ASignal_List(temp);
}
public virtual void Init(Signals UISignals)
{
this.UISignals = UISignals;
BuildBoard();
foreach (GameHex gHex in Hexes)
{
gHex.SetColourInner(inner);
gHex.SetColourOuter(outer);
}
}
void checkPos()
{
if (GetComponent <LineRenderer>())
{
return;
}
Vector3 pos = GetComponent <Transform>().position;
if (pos.x > Global.Instance.MaxCameraBounds.x || pos.y > Global.Instance.MaxCameraBounds.y ||
pos.x < Global.Instance.MinCameraBounds.x || pos.y < Global.Instance.MinCameraBounds.y)
{
Signals.DestroyObjReq();
Destroy(gameObject);
}
}
public BlockStoreFeature(ConcurrentChain chain, IConnectionManager connectionManager, Signals signals, BlockRepository blockRepository,
BlockStoreCache blockStoreCache, StoreBlockPuller blockPuller, BlockStoreLoop blockStoreLoop, BlockStoreManager blockStoreManager,
BlockStoreSignaled blockStoreSignaled, INodeLifetime nodeLifetime, NodeSettings nodeSettings)
{
this.chain = chain;
this.signals = signals;
this.blockRepository = blockRepository;
this.blockStoreCache = blockStoreCache;
this.blockPuller = blockPuller;
this.blockStoreLoop = blockStoreLoop;
this.blockStoreManager = blockStoreManager;
this.blockStoreSignaled = blockStoreSignaled;
this.nodeLifetime = nodeLifetime;
this.connectionManager = connectionManager;
this.nodeSettings = nodeSettings;
}
// called from editor script!
public void OnMarkerFound()
{
if (showWhenTracked != null)
{
showWhenTracked.SetActive(true);
}
var scene = gameObject.GetComponentInParent <ARScene>();
if (scene != null)
{
scene.MarkerFound();
}
Signals.Get <ARMarkerFoundSignal>().Dispatch();
}
public void Awake()
{
animator = GetComponentInChildren <Animator>();
if (PersisterPlayerInputInfo.players != null)
{
if (!PersisterPlayerInputInfo.players.ContainsKey(playerId))
{
Destroy(gameObject);
return;
}
GetComponent <PlayerInput>().joystickId = PersisterPlayerInputInfo.players[playerId];
}
alive = true;
MatchManager.Instance.AddPlayer(this);
Signals.Get <PlayerKilled>().AddListener(CheckDeath);
}
public void LoadSignals(string filePath)
{
if (!File.Exists(filePath))
{
throw new FileNotFoundException(string.Format("The signals file doesn't exist at: {0}", filePath));
}
using (var fileStream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
var serializer = new XmlSerializer(this.GetType());
var signals = (serializer.Deserialize(fileStream) as SignalContainer).Signals;
Signals.AddRange(signals);
}
}
private void Start()
{
var playerController = _player.GetComponent <PlayerController>();
if (playerController)
{
_startTextSo.AddEvent(() => playerController.SetState(PlayerStates.Talking));
_startTextSo.AddEvent(() =>
{
AreaEvent();
playerController.Animator.SetBool(Talking, false);
});
Signals.Get <OnMemoryGameWon>().AddListener(() => GameWonEvents(playerController));
}
}
public BlockStoreFeature(ConcurrentChain chain, ConnectionManager connectionManager, Signals signals, BlockRepository blockRepository,
BlockStoreCache blockStoreCache, StoreBlockPuller blockPuller, BlockStoreLoop blockStoreLoop, BlockStoreManager blockStoreManager,
BlockStoreSignaled blockStoreSignaled, FullNode.CancellationProvider cancellationProvider, NodeSettings nodeSettings)
{
this.chain = chain;
this.signals = signals;
this.blockRepository = blockRepository;
this.blockStoreCache = blockStoreCache;
this.blockPuller = blockPuller;
this.blockStoreLoop = blockStoreLoop;
this.blockStoreManager = blockStoreManager;
this.blockStoreSignaled = blockStoreSignaled;
this.cancellationProvider = cancellationProvider;
this.connectionManager = connectionManager;
this.nodeSettings = nodeSettings;
}
public TumbleBitManager(ILoggerFactory loggerFactory, WalletManager walletManager, WatchOnlyWalletManager watchOnlyWalletManager, ConcurrentChain chain, Network network, Signals signals, WalletTransactionHandler walletTransactionHandler, BlockStoreManager blockStoreManager, MempoolManager mempoolManager, WalletSyncManager walletSyncManager)
{
this.walletManager = walletManager;
this.watchOnlyWalletManager = watchOnlyWalletManager;
this.walletSyncManager = walletSyncManager;
this.walletTransactionHandler = walletTransactionHandler;
this.chain = chain;
this.signals = signals;
this.network = network;
this.loggerFactory = loggerFactory;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.blockStoreManager = blockStoreManager;
this.mempoolManager = mempoolManager;
this.tumblingState = new TumblingState(loggerFactory, this.chain, this.walletManager, this.watchOnlyWalletManager, this.network, this.walletTransactionHandler, this.blockStoreManager, this.mempoolManager, this.walletSyncManager);
}
public void IdealSignalNextClose()
{
var bars = new DataSeries <Bar>("", new[] {
new Bar(5, 0, 0, 10, 0),
new Bar(6, 0, 0, 11, 0),
new Bar(5, 0, 0, 12, 0),
new Bar(4, 0, 0, 11, 0),
new Bar(3, 0, 0, 10, 0),
new Bar(1, 0, 0, 12, 0),
new Bar(10, 0, 0, 12, 0)
});
var signal = bars.MapElements <Value>((s, _) => Signals.NextClose(s)).Select(x => x.Val).ToList();
signal.ShouldEnumerateLike(Lists.Create <double>(0, 1, 1, -1, -1, 1, 1));
}
void signals_ItemRemoved(object sender, SignalEventArgs e)
{
selectedSignal.Items.Remove(e.Signal.Tag);
if (!Signals.Contains(SelectedSignal))
{
if (Signals.Any())
{
SelectedSignal = Signals.First();
}
else if (SelectedSignal != null)
{
SelectedSignal = null;
}
}
}
override public void Start()
{
base.Start();
this.type = EntityType.PESTO;
Signals.Get <HitByBulletSignal>().AddListener(OnBulletHit);
Signals.Get <SpawningSignal>().AddListener(OnEnemySpawn);
/* attackResponses.Add((AttackData data) => {
* return new PestoDialogue("<j=crazy>See you later, fucko!!!", PestoEmote.ANGRY);
* });
*
* spawnResponses.Add((EntityType entitySpawning) => {
* return new PestoDialogue("We got company!!!", PestoEmote.SCARED);
* });*/
}
void Update()
{
pos = GetComponent <Transform>().position;
Global.Instance.TuggerPos = pos;
if (Input.GetMouseButtonDown(1))
{
active = true;
}
else if (Input.GetMouseButtonUp(1))
{
active = false;
}
if (active)
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
GetComponent <Transform>().position = ray.GetPoint(0f);
}
if (grabbedObjs.Count > 0)
{
foreach (GameObject obj in grabbedObjs.ToArray())
{
if (obj == null)
{
grabbedObjs.Remove(obj); return;
}
if (obj.GetComponent <Rigidbody2D>().gravityScale != 0)
{
obj.GetComponent <Rigidbody2D>().gravityScale = 0;
}
obj.GetComponent <Rigidbody2D>().position = Vector3.Lerp(obj.GetComponent <Transform>().position, pos, Time.deltaTime * force);
if ((obj.GetComponent <Transform>().position - pos).sqrMagnitude <= 94.65f) //95
{
if (obj.GetComponent <Obj>().isCorrupted)
{
Global.Instance.Health -= 1;
}
Signals.DestroyObjReq();
grabbedObjs.Remove(obj);
GameObject.Destroy(obj);
}
}
}
}
// - DATA OUTPUT SETTINGS -----------------------------------------------
/*
* const string dateFormat = "yyyy-MM-dd HH:mm:ss";
* private string maxDate = "";
* private bool isFirstBar = true;
* private MySqlConnection conn;
*/
protected override void Initialize()
{
// Initialize and create nested indicators ---------------------
pairID = Symbol.Code;
debug_PrintValues = false;
// HeikenAshi Standard -----------------------------------------
if (enable_HeikenAshi)
{
_haOpen = CreateDataSeries();
_haClose = CreateDataSeries();
if (!Enum.TryParse <Colors>(UpColor, out _upColor) || !Enum.TryParse <Colors>(DownColor, out _downColor))
{
_incorrectColors = true;
}
}
// MOVING AVERAGE -----------------------------------------
if (enable_EMA)
{
exp = 2.0 / (Periods + 1);
}
// SCALPER SIGNAL -----------------------------------------------
if (enable_ScalperSignal)
{
if (!Enum.TryParse <Colors>(SignalBarColor, out signalBarColor))
{
signalBarColor = Colors.Gold;
}
lastSignal = Signals.None;
lastTime = new DateTime();
lastTime = MarketSeries.OpenTime[MarketSeries.Close.Count - 1];
}
// BOLLINGER BANDS -------------------------------------------------
if (enable_BollingerBands)
{
_bbmovingAverage = Indicators.MovingAverage(Price, Period, MaType);
_bbstandardDeviation = Indicators.StandardDeviation(Price, Period, MaType);
}
// START LOGGIN ENGINE --------------------------------------------
//initialize_logging();
}
private void Die(Vector3 directionToThrow)
{
isDying = true;
agent.enabled = false;
thisAnimator.enabled = false;
aICharacter.enabled = false;
thisRigidbody.isKinematic = true;
TurnRagdollOnOrOff(true);
thisAudiosource.clip = (dyingSFX[Random.Range(0, dyingSFX.Length)]);
thisAudiosource.Play();
Signals.Get <EnemyKilledSignal>().Dispatch(gameObject.GetInstanceID());
rigidbodyToPull.AddForce(directionToThrow * 20);
Invoke(MethodNamesDatabase.killMeString, 5f);
}
private void OnItemPointerEnter(ItemOrigin origin, int itemId, PointerEventData eventData)
{
string itemDefId = string.Empty;
if (origin == ItemOrigin.PlayerInventory)
{
itemDefId = _inventoryQuery.TakeSnapshot().Single(item => item.id == itemId).definitionId;
}
if (origin == ItemOrigin.Vendor)
{
itemDefId = _vendorQuery.TakeSnapshot().Single(item => item.id == itemId).definitionId;
}
Signals.Get <OnShowTooltipSignal>().Invoke(itemDefId);
}
private static CtrlType GetSignum(Signals signal)
{
switch (signal)
{
case Signals.CtrlC:
return(CtrlType.CTRL_C_EVENT);
case Signals.CtrlBreak:
return(CtrlType.CTRL_BREAK_EVENT);
case Signals.CtrlShutdown:
return(CtrlType.CTRL_CLOSE_EVENT);
default:
throw new NotSupportedException();
}
}
public void SetSignal(Signals signal)
{
currentSignal_ = signal;
if (currentSignal_ == Signals.S_STOP)
{
redLight_.color = Color.red;
greenLight_.color = Color.black;
gameObject.layer = LayerMask.NameToLayer("Default");
}
else
{
redLight_.color = Color.black;
greenLight_.color = Color.green;
gameObject.layer = LayerMask.NameToLayer("Ignore Raycast");
}
}
public void AddSignal(Signal signalIn)
{
// 特殊ID表示该报文作为未使用信号的容器，不必检查新信号的合法性
if (ID != 0xC0000000)
{
if (signalIn.Message != null)
{
throw new ApplicationException("Signal already belongs to message: " + signalIn.Message.Name);
}
if (!CheckSignalPosition(signalIn))
{
throw new ApplicationException("Signal position doesn't fit in message layout");
}
}
AddChild(signalIn);
Signals.Add(signalIn.Name, signalIn);
}
public void UpdateGround(List <Vector3> shapePoints = null)
{
// Skip cubes intersected by cutting line
for (var i = 0; i < shapePoints.Count; i++)
{
var cubeX = (int)Mathf.Floor(shapePoints[i].x * _pointsPerUnit);
var cubeZ = (int)Mathf.Floor(shapePoints[i].z * _pointsPerUnit);
if (!_skippedQuads[cubeX, 0, cubeZ])
{
_skippedQuads[cubeX, 0, cubeZ] = true;
// Debug.DrawLine(
// (new Vector3(cubeX, 0, cubeZ) + Vector3.forward * .5f + Vector3.right * .5f) / _pointsPerUnit,
// (new Vector3(cubeX, 1, cubeZ) + Vector3.forward * .5f + Vector3.right * .5f) / _pointsPerUnit,
// Color.green,999);
}
}
// Find floating islands and drop them
for (int z = 1; z < _zPoints - 1; z++)
{
for (int x = 1; x < _xPoints - 1; x++)
{
if (MyMaths.ContainsPoint(shapePoints, (new Vector3(x, 0, z) + Vector3.forward * .5f + Vector3.right * .5f) / _pointsPerUnit))
{
_skippedQuads[x, 0, z] = true;
// Debug.DrawLine(
// (new Vector3(x, 0, z) + Vector3.forward * .5f + Vector3.right * .5f) / _pointsPerUnit,
// (new Vector3(x, 2, z) + Vector3.forward * .5f + Vector3.right * .5f) / _pointsPerUnit,
// Color.yellow, 999);
}
}
}
RegenerateMesh(shapePoints);
var hole = CreateHoleObject(shapePoints);
var walls = CreateHoleWallObject(shapePoints);
GiveHoleACollider(hole);
Signals.Get <HoleGeneratedSignal>().Dispatch(hole, walls);
// Debug.Log($"HoleGeneratedSignal F={Time.frameCount}", gameObject);
_holeId++;
}
private async void DoScan()
{
var settings = SettingsStore.Load();
SetStatusText($"initializing {settings.Exchange} with 24hr volume of {settings.Min24HrVolume} ...");
_scanner = new Scanner(settings);
while (_running)
{
int idx = 0;
foreach (var symbol in _scanner.Symbols)
{
idx++;
SetStatusText($"{settings.Exchange} scanning {symbol} ({idx}/{_scanner.Symbols.Count})...");
var signal = await _scanner.ScanAsync(symbol);
if (signal != null)
{
await Dispatcher.UIThread.InvokeAsync(() =>
{
Signals.Insert(0, signal);
});
}
}
if (!_running)
{
break;
}
SetStatusText($"sleeping.");
Thread.Sleep(1000);
if (!_running)
{
break;
}
SetStatusText($"sleeping..");
Thread.Sleep(1000);
if (!_running)
{
break;
}
SetStatusText($"sleeping...");
Thread.Sleep(1000);
}
}
public void AddData(List <Signal> e)
{
if (e != null && e.Count > 0)
{
var startT = e.FirstOrDefault().TimeStamps.FirstOrDefault();
if (FirstFile)
{
TimeZero = startT;
//FirstFileRead = true;
FirstFile = false;
}
//else if (TimeZero >= startT)
//{
// throw new Exception("Possible data source files time order problem.");
//}
var endT = e.FirstOrDefault().TimeStamps.LastOrDefault();
//Console.WriteLine("Added end timestamp: " + endT.ToString("yyyyMMdd_HHmmss.ffffff") + " in " + e.FirstOrDefault().TimeStamps.Count() + " timestamps.");
foreach (var sig in e)
{
var name = sig.PMUName + "_" + sig.SignalName;
lock (_theInputSignalsLock)
{
if (!Signals.ContainsKey(name))
{
Signals[name] = new Dictionary <DateTime, Signal>();
}
Signals[name][endT] = sig;
}
}
lock (_theDataWriterLock)
{
if (!_doneDataWriterFlags.ContainsKey(endT))
{
_doneDataWriterFlags[endT] = new List <bool>();
}
TimePairs[startT] = endT;
StartTimeStamps.Add(startT);
}
lock (_theEndTimeStampsLock)
{
EndTimeStamps.Add(endT);
}
}
}
private void Update()
{
if (Input.GetKeyUp(KeyCode.Escape) && gameStarted == true)
{
if (gamePaused)
{
Signals.Get <GameUnPausedSignal>().Dispatch();
}
else
{
Signals.Get <GamePausedSignal>().Dispatch();
}
}
if (Input.GetKey(KeyCode.Return) || Input.GetKey(KeyCode.KeypadEnter))
{
if (gameStarted == false)
{
Signals.Get <GameStartedSignal>().Dispatch();
}
else if (winScreenShown)
{
gameDirector.RestartGame();
}
}
if (inputBlocked == true)
{
return;
}
if (Input.GetKey(KeyCode.Alpha1))
{
Signals.Get <SwitchedWeaponSignal>().Dispatch(WeaponType.FastGun);
}
if (Input.GetKey(KeyCode.Alpha2))
{
Signals.Get <SwitchedWeaponSignal>().Dispatch(WeaponType.RailGun);
}
if (Input.GetKey(KeyCode.Alpha3))
{
Signals.Get <SwitchedWeaponSignal>().Dispatch(WeaponType.Bazooka);
}
if (Input.GetMouseButton(0))
{
player.Shooting();
}
}
// Mouse release handler
private void OnReleaseHandler()
{
if (IsEnabled && Time.realtimeSinceStartup - _interactionTime > _interactionDelay)
{
if (IsPressed)
{
IsPressed = false;
OnClick.InvokeIfNotNull();
Signals.DispatchGroup(_signalsClick);
}
SetState(IsHovered ? State.Hover : State.Normal);
_interactionTime = Time.realtimeSinceStartup;
}
}
private void LoadSignalsFromActiveWorkBook()
{
Signals.Clear();
SignalViews.Clear();
List <Signal> signals = new List <Signal>(workBookManager.ActiveWorkBook().Signals.Values);
// No addrange for observeablecollection
foreach (Signal signal in signals.Where(sig => sig.Type == SignalType.Source))
{
signal.PropertyChanged -= handleSignalUpdate;
Signals.Add(signal);
SignalViews.Add(new SignalItemView {
DataContext = signal
});
signal.PropertyChanged += handleSignalUpdate;
}
}
void OnBulletHit(AttackData attackData)
{
bool giveResponse = Random.value > 0.9f;
if (giveResponse == true)
{
foreach (Func <AttackData, PestoDialogue> func in attackResponses)
{
PestoDialogue dialogue = func(attackData);
if (dialogue.dialogue != "")
{
Signals.Get <ShowDialogueMessageSignal>().Dispatch(dialogue.dialogue, dialogue.pestoEmote, true);
attackResponses.Remove(func);
break;
}
}
}
}
private void OnPlayerResourcesGiven(int sourcePlayerNum, int destPlayerNum, ResourceType type, int amount)
{
if (!PlayersManager.Instance.GetPlayer(sourcePlayerNum).CanDonateAmount(type, amount))
{
return;
}
if (sourcePlayerNum == Data.Num)
{
Data.Resources[type] -= amount;
Signals.PublishPlayerUpdatedEvent(Data, true);
}
else if (destPlayerNum == Data.Num)
{
Data.Resources[type] += amount;
Signals.PublishPlayerUpdatedEvent(Data, true);
}
}
public string GetNextState(string currentState, Signals currentSignals)
{
if (this.table.ContainsKey(currentState))
{
var transitionsForCurrentState = this.table[currentState];
if (transitionsForCurrentState != null)
{
foreach (var possibleState in transitionsForCurrentState.Keys)
{
if (transitionsForCurrentState[possibleState](currentSignals))
{
return(possibleState);
}
}
}
}
throw new Exception($"Transition for {currentState} not defined when signals {currentSignals}.");
}
void OnEnemySpawn(EntityType enemySpawning)
{
bool giveResponse = Random.value > 0.9f;
if (giveResponse == true)
{
foreach (Func <EntityType, PestoDialogue> func in spawnResponses)
{
PestoDialogue dialogue = func(enemySpawning);
if (dialogue.dialogue != "")
{
Signals.Get <ShowDialogueMessageSignal>().Dispatch(dialogue.dialogue, dialogue.pestoEmote, true);
spawnResponses.Remove(func);
break;
}
}
}
}
private void Awake()
{
_surroundingEnergy = -_playerData.EnergyLossInFog;
Signals.Get(out _enterSafeZoneSignal);
Signals.Get(out _exitSafeZoneSignal);
Signals.Get(out _playerDiedSignal);
Signals.Get(out _victorySignal);
Signals.Get(out _playerEnergyLevelChangedSignal);
Signals.Get(out _waterCollectedSignal);
_enterSafeZoneSignal.AddListener(OnEnterSafeZone);
_exitSafeZoneSignal.AddListener(OnExitSafeZone);
_playerEnergyLevelChangedSignal.AddListener(OnEnergyLevelChanged);
_playerDiedSignal.AddListener(OnPlayerDied);
_victorySignal.AddListener(OnVictory);
_waterCollectedSignal.AddListener(OnWaterCollected);
}
public MempoolOrphans(MempoolScheduler mempoolScheduler, TxMempool memPool, ConcurrentChain chain, Signals signals,
MempoolValidator validator, PowConsensusValidator consensusValidator, CoinView coinView, IDateTimeProvider dateTimeProvider, NodeSettings nodeArgs)
{
this.MempoolScheduler = mempoolScheduler;
this.memPool = memPool;
this.chain = chain;
this.signals = signals;
this.consensusValidator = consensusValidator;
this.coinView = coinView;
this.dateTimeProvider = dateTimeProvider;
this.nodeArgs = nodeArgs;
this.Validator = validator;
this.mapOrphanTransactions = new Dictionary <uint256, OrphanTx>();
this.mapOrphanTransactionsByPrev = new Dictionary <OutPoint, List <OrphanTx> >(); // OutPoint already correctly implements equality compare
this.recentRejects = new Dictionary <uint256, uint256>();
this.hashRecentRejectsChainTip = uint256.Zero;
}
void Start()
{
UISignals = gameObject.GetComponent<Signals>();
UISignals.AddListeners(OnSignal, new List<Signal>() {
Signal.PuzzleComplete });
}
/// <summary>
/// Send a signal to the server.
/// </summary>
/// <param name="signal"></param>
public Signal(Signals signal)
{
this.signal = signal;
}
void Start()
{
Layout.defaultLayout = new Layout(Layout.pointy, new Point(layoutSize, layoutSize), new Point(0, 0));
Signals = FindObjectOfType<Signals>();
UIState = FindObjectOfType<UIStates>();
Signals.AddListeners(OnUISignal, new List<Signal>() {
Signal.RotateCCW,
Signal.RotateUndo,
Signal.RotateCW,
Signal.EndTurn});
players = new List<Player>();
for (int i = 0; i < numPlayers; i++)
{
Player p = new Player();
players.Add(p);
p.Name = "Player" + i;
}
StartGame();
}
public void Construct(
GameController gameController, Signals.ShipCrashed shipCrashed)
{
_gameController = gameController;
_shipCrashed = shipCrashed;
}
/// <summary>
/// 构造函数,从数据库中读取包含给定ControllerAddr,DocumentName,SheetName的Cld_Module的集合
/// </summary>
/// <param name="conn">到数据库的连接</param>
/// <param name="ControllerAddr">Controller Address</param>
/// <param name="DocumentName">Document Name</param>
/// <param name="SheetName">Sheet Name</param>
/// <param name="metamodules">Meta_Modules</param>
public Cld_ModuleS(OleDbConnection conn, string ControllerAddr, string DocumentName, string SheetName, Meta_ModuleS metamodules)
{
//进行必要的初始化
cld_modules = new Hashtable();
signals = new Signals();
cld_signals = new Cld_SignalS();
meta_modules = metamodules;
this.ControllerAddr = ControllerAddr;
this.DocumentName = DocumentName;
this.SheetName = SheetName;
//建立数据库连接
if (conn.State == ConnectionState.Closed)
{
try
{
conn.Open();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
//数据库操作字符串
string sql_string = "SELECT * FROM Cld_FCMaster WHERE ControllerAddress='" + ControllerAddr +
"' AND DocumentName='" + DocumentName + "' AND SheetName='" + SheetName + "'";
OleDbDataAdapter Cld_FCMaster_Adapter = new OleDbDataAdapter(sql_string, conn);
DataSet myDataSet = new DataSet();
Cld_FCMaster_Adapter.Fill(myDataSet, "Cld_FCMaster");
//处理CLD FCMaster表的每一行
for (int i = 0; i < myDataSet.Tables["Cld_FCMaster"].Rows.Count; i++)
{
Cld_Module cld_module_temp = new Cld_Module();
//处理相应的Cld_FCMaster表
cld_module_temp.ObjectID = myDataSet.Tables["Cld_FCMaster"].Rows[i]["ObjectID"].ToString();
cld_module_temp.ControllerAddress = myDataSet.Tables["Cld_FCMaster"].Rows[i]["ControllerAddress"].ToString();
cld_module_temp.DocumentName = myDataSet.Tables["Cld_FCMaster"].Rows[i]["DocumentName"].ToString();
cld_module_temp.SheetName = myDataSet.Tables["Cld_FCMaster"].Rows[i]["SheetName"].ToString();
cld_module_temp.AlgName = myDataSet.Tables["Cld_FCMaster"].Rows[i]["AlgName"].ToString();
cld_module_temp.AlgOrder = myDataSet.Tables["Cld_FCMaster"].Rows[i]["AlgOrder"].ToString();
cld_module_temp.FunctionName = myDataSet.Tables["Cld_FCMaster"].Rows[i]["FunctionName"].ToString();
cld_module_temp.X_Y = myDataSet.Tables["Cld_FCMaster"].Rows[i]["X_Y"].ToString();
cld_module_temp.SymbolName = myDataSet.Tables["Cld_FCMaster"].Rows[i]["SymbolName"].ToString();
cld_module_temp.DESCRP = myDataSet.Tables["Cld_FCMaster"].Rows[i]["DESCRP"].ToString();
cld_module_temp.PERIOD = myDataSet.Tables["Cld_FCMaster"].Rows[i]["PERIOD"].ToString();
cld_module_temp.PHASE = myDataSet.Tables["Cld_FCMaster"].Rows[i]["PHASE"].ToString();
cld_module_temp.LOOPID = myDataSet.Tables["Cld_FCMaster"].Rows[i]["LOOPID"].ToString();
//处理相应的Cld_FCDetail表
sql_string = "SELECT * FROM Cld_FCDetail WHERE ObjectID='" + cld_module_temp.ObjectID + "'";
OleDbDataAdapter Cld_FCDetail_Adapter = new OleDbDataAdapter(sql_string, conn);
Cld_FCDetail_Adapter.Fill(myDataSet, "Cld_FCDetail");
for (int m = 0; m < myDataSet.Tables["Cld_FCDetail"].Rows.Count; m++)
{
Cld_Module_Pin cld_module_pin_temp = new Cld_Module_Pin();
//对Cld_Module_Pin对象进行数据的填充
cld_module_pin_temp.ObjectID = myDataSet.Tables["Cld_FCDetail"].Rows[m]["ObjectID"].ToString();
cld_module_pin_temp.PinName = myDataSet.Tables["Cld_FCDetail"].Rows[m]["PinName"].ToString();
cld_module_pin_temp.PinValue = myDataSet.Tables["Cld_FCDetail"].Rows[m]["PinValue"].ToString();
cld_module_pin_temp.NetworkID = myDataSet.Tables["Cld_FCDetail"].Rows[m]["NetworkID"].ToString();
cld_module_pin_temp.IsHistory = (bool)(myDataSet.Tables["Cld_FCDetail"].Rows[m]["IsHistory"]);
cld_module_pin_temp.Point = myDataSet.Tables["Cld_FCDetail"].Rows[m]["Point"].ToString();
cld_module_temp.Pins[cld_module_pin_temp.PinName] = cld_module_pin_temp;
if (metamodules.Pin_Type(cld_module_temp.FunctionName, cld_module_pin_temp.PinName).Equals("Input"))
{
cld_module_pin_temp.PinType = "Input";
cld_module_temp.PinType[cld_module_pin_temp.PinName] = "Input";
cld_module_temp.Input_Pin[cld_module_pin_temp.PinName] = cld_module_pin_temp;
}
else if (metamodules.Pin_Type(cld_module_temp.FunctionName, cld_module_pin_temp.PinName).Equals("Output"))
{
cld_module_pin_temp.PinType = "Output";
cld_module_temp.PinType[cld_module_pin_temp.PinName] = "Output";
cld_module_temp.Out_Pin[cld_module_pin_temp.PinName] = cld_module_pin_temp;
}
else if (metamodules.Pin_Type(cld_module_temp.FunctionName, cld_module_pin_temp.PinName).Equals("Constant"))
{
cld_module_temp.PinType[cld_module_pin_temp.PinName] = "Constant";
cld_module_pin_temp.PinType = "Constant";
//cld_module_temp.Constant_Pin.Add(cld_module_pin_temp);
cld_module_temp.Constant_Pin[cld_module_pin_temp.PinName] = cld_module_pin_temp;
}
else if (metamodules.Pin_Type(cld_module_temp.FunctionName, cld_module_pin_temp.PinName).Equals("Internal"))
{
cld_module_pin_temp.PinType = "Internal";
cld_module_temp.PinType[cld_module_pin_temp.PinName] = "Internal";
//cld_module_temp.Internal_Pin.Add(cld_module_pin_temp);
cld_module_temp.Internal_Pin[cld_module_pin_temp.PinName] = cld_module_pin_temp;
}
else
{
//没有这种类型的引脚，因该是数据库有问题
cld_module_temp.PinType[cld_module_pin_temp.PinName] = "";
cld_module_pin_temp.PinType = "";
}
}
myDataSet.Tables["Cld_FCDetail"].Clear();
cld_modules[cld_module_temp.ObjectID] = cld_module_temp;
}
//读取数据完毕
myDataSet.Dispose();
Cld_FCMaster_Adapter.Dispose();
conn.Close();
}
void Awake()
{
UIState = gameObject.GetComponent<UIStates>();
Signals = gameObject.GetComponent<Signals>();
}
internal static extern int Kill(int pid, Signals signal);
public static AssertResult That(Shelisp.Object o, Signals signals, string lisp_error, string description = null)
{
try {
o.Eval (TestRunner.L);
return FailExpectedLispError (lisp_error, description);
}
catch (LispException le) {
if (le.Symbol == L.intern (lisp_error))
return Succeed (description);
else
return FailExpectedLispError (lisp_error, le, description);
}
catch (Exception e) {
return FailException (e, description);
}
}
/// <summary>
/// The application must call main after it has
/// instantiated the derived class. main creates
/// a communicator, establishes the specified signal policy, and,
/// once run returns, destroys the communicator.
/// The method prints an error message for any exception that propagates
/// out of run and ensures that the communicator is
/// destroyed correctly even if run completes abnormally.
/// </summary>
/// <param name="args">The arguments for the application (as passed to Main(string[])
/// by the operating system.</param>
/// <param name="initializationData">Additional data used to initialize the communicator.</param>
/// <returns>The value returned by run. If run terminates with an exception,
/// the return value is non-zero.</returns>
public int main(string[] args, InitializationData initializationData)
{
if(Util.getProcessLogger() is ConsoleLoggerI)
{
Util.setProcessLogger(new ConsoleLoggerI(appName__));
}
if(communicator__ != null)
{
Util.getProcessLogger().error("only one instance of the Application class can be used");
return 1;
}
//
// We parse the properties here to extract Ice.ProgramName.
//
InitializationData initData;
if(initializationData != null)
{
initData = (InitializationData)initializationData.Clone();
}
else
{
initData = new InitializationData();
}
try
{
initData.properties = Util.createProperties(ref args, initData.properties);
}
catch(Ice.Exception ex)
{
Util.getProcessLogger().error(ex.ToString());
return 1;
}
catch(System.Exception ex)
{
Util.getProcessLogger().error("unknown exception:\n" + ex);
return 1;
}
appName__ = initData.properties.getPropertyWithDefault("Ice.ProgramName", appName__);
nohup__ = initData.properties.getPropertyAsInt("Ice.Nohup") > 0;
_application = this;
int status;
if(signalPolicy__ == SignalPolicy.HandleSignals)
{
if(IceInternal.AssemblyUtil.platform_ == IceInternal.AssemblyUtil.Platform.Windows)
{
_signals = new WindowsSignals();
}
else
{
_signals = new MonoSignals();
}
_signals.register(_handler);
status = doMain(args, initData);
_signals.destroy();
_signals = null;
}
else
{
status = doMain(args, initData);
}
return status;
}
