public void DispatchInvalid()
{
SignalManager <int> signalManager = new SignalManager <int>();
signalManager.AddListener(0, () => { });
Assert.That(() => signalManager.Dispatch(0, 7), Throws.InvalidOperationException);
}
public override void OnReceived(IncomingMessage msg)
{
switch (msg.ReadInt32())
{
case MessageTypes.Spawn:
SignalManager.Signal(Spawn.Read(msg));
break;
case MessageTypes.SynchronizeMessage:
WorldUpdate update = new WorldUpdate();
update.Read(msg);
for (int i = 0; i < 2; i++)
{
SignalManager.Signal(update.Players[i]);
}
break;
case MessageTypes.Move:
SignalManager.Signal(Movement.Read(msg));
break;
case MessageTypes.WorldState:
break;
}
}
private async void ProcessImage(ProjectItem item, TileSetModel tileSet, string filePath)
{
string imagesFolder = (string)Application.Current.FindResource(_folderImagesKey);
ProjectModel projectModel = ModelManager.Get <ProjectModel>();
string imageFolderFullPath = Path.Combine(projectModel.ProjectPath, imagesFolder);
if (!Directory.Exists(imageFolderFullPath))
{
_ = Directory.CreateDirectory(imageFolderFullPath);
}
PaletteQuantizer quantizer = new PaletteQuantizer
{
InputFileName = filePath,
ColorCache = PaletteQuantizer.EColorCache.OctreeSearch,
Method = PaletteQuantizer.EMethod.NESQuantizer
};
// todo: If the source image is the same as the output image, Crash!!
Image outputImage = await quantizer.Convert();
string outputImagePath = Path.Combine(imageFolderFullPath, item.DisplayName + ".bmp");
tileSet.ImagePath = Path.Combine(imagesFolder, item.DisplayName + ".bmp");
tileSet.ImageWidth = outputImage.Width;
tileSet.ImageHeight = outputImage.Height;
item.FileHandler.Save();
outputImage.Save(outputImagePath, ImageFormat.Bmp);
SignalManager.Get <UpdateTileSetImageSignal>().Dispatch();
}
private ProjectItem CreateTileSetElement(string name)
{
ProjectModel projectModel = ModelManager.Get <ProjectModel>();
string tileSets = (string)Application.Current.FindResource(_folderTileSetsKey);
string path = Path.Combine(projectModel.ProjectPath, tileSets);
name = ProjectItemFileSystem.GetValidFileName(
path,
name,
Util.GetExtensionByType(ProjectItemType.TileSet));
ProjectItem newElement = new ProjectItem()
{
DisplayName = name,
IsFolder = false,
IsRoot = false,
Type = ProjectItemType.TileSet
};
SignalManager.Get <RegisterHistoryActionSignal>().Dispatch(new CreateNewElementHistoryAction(newElement));
SignalManager.Get <FindAndCreateElementSignal>().Dispatch(newElement);
ProjectItemFileSystem.CreateFileElement(newElement, path, name);
return(newElement);
}
private void Construct(SignalManager manager, SignalSettings settings, BindInfo bindInfo)
{
_manager = manager;
SignalId = new BindingId(this.GetType(), bindInfo.Identifier);
Settings = settings;
}
void Start()
{
mainManager = GameObject.Find("MainManager").GetComponent <MainManager>();
signalManager = GameObject.Find("SignalManager").GetComponent <SignalManager>();
musicManager = GameObject.Find("MusicManager").GetComponent <MusicManager>();
prefabCreator = GameObject.Find("PrefabCreator").GetComponent <PrefabCreator>();
ball = GameObject.Find("TheBall").GetComponent <Ball>();
audioSources = GetComponents <AudioSource>();
body = gameObjectBody.GetComponent <SKL144SystemBody>();
face = gameObjectFace.GetComponent <SKL144SystemFace>();
motionTriggers[1] = motionTrigger1;
motionTriggers[2] = motionTrigger2;
motionTriggers[3] = motionTrigger3;
durations[1] = duration1;
durations[2] = duration2;
durations[3] = duration3;
isIdle = true;
duration = duration1;
}
public virtual object WaitSignal(HttpContext context)
{
YZRequest request = new YZRequest(context);
string signalId = request.GetString("signalId");
int count;
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
count = SignalManager.GetSignalCount(provider, cn, signalId);
if (count != 0)
{
SignalManager.DeleteSignal(provider, cn, signalId);
}
}
}
if (count != 0)
{
return(new
{
success = true
});
}
else
{
return(new
{
success = false
});
}
}
private void LoadProject(string directoryPath, string projectFullPath, string projectName)
{
// Clean up previous stuff
ProjectFiles.Handlers.Clear();
ProjectModel projectModel = ModelManager.Get <ProjectModel>();
if (projectModel.IsOpen())
{
SignalManager.Get <CloseProjectSuccessSignal>().Dispatch();
}
SignalManager.Get <ShowLoadingDialogSignal>().Dispatch();
// load project configuration file
projectModel.Load(directoryPath, projectFullPath);
// load project folder
DirectoryInfo d = new DirectoryInfo(directoryPath);
DirectoryInfo[] directories = d.GetDirectories();
List <ProjectItem> projectItems = new List <ProjectItem>();
ScanDirectories(directories, ref projectItems);
SignalManager.Get <OpenProjectSuccessSignal>().Dispatch(new ProjectOpenVO()
{
Items = projectItems, ProjectName = projectName
});
UpdateConfigurations(directoryPath);
}
public override void Execute(object parameter)
{
if (!(parameter is ElementTypeModel element))
{
return;
}
string name = ProjectItemFileSystem.GetValidFileName(
element.Path,
_newFileName,
Util.GetExtensionByType(element.Type));
ProjectItem newElement = new ProjectItem()
{
DisplayName = name,
IsFolder = false,
IsRoot = false,
Type = element.Type
};
SignalManager.Get <RegisterHistoryActionSignal>().Dispatch(new CreateNewElementHistoryAction(newElement));
SignalManager.Get <FindAndCreateElementSignal>().Dispatch(newElement);
ProjectItemFileSystem.CreateFileElement(newElement, element.Path, name);
}
void OnDestroy()
{
if (instance == this)
{
instance = null;
}
}
public override void Execute(object parameter)
{
if (ItemSelected == null || ItemSelected.FileHandler == null)
{
return;
}
string path = Path.Combine(ItemSelected.FileHandler.Path, ItemSelected.FileHandler.Name);
string name = ProjectItemFileSystem.GetValidFolderName(path, _newFolderName);
ProjectItem newFolder = new ProjectItem()
{
DisplayName = name,
IsFolder = true,
Parent = ItemSelected,
IsRoot = false,
Type = ItemSelected.Type
};
ItemSelected.Items.Add(newFolder);
SignalManager.Get <RegisterHistoryActionSignal>().Dispatch(new CreateNewElementHistoryAction(newFolder));
SignalManager.Get <CreateNewElementSignal>().Dispatch(newFolder);
ProjectItemFileSystem.CreateFileElement(newFolder, path, name);
}
// Use this for initialization
void Start()
{
mainManager = GameObject.Find("MainManager").GetComponent <MainManager>();
itemManager = GameObject.Find("ItemManager").GetComponent <ItemManager>();
signalManager = GameObject.Find("SignalManager").GetComponent <SignalManager>();
prefabSounds = GameObject.Find("PrefabSounds").GetComponent <PrefabSounds>();
ball = GameObject.Find("TheBall").GetComponent <Ball>();
racket = GameObject.Find("TheRacket").GetComponent <Racket>();
if (itemCode >= 0)
{
itemCode = mainManager.GetCurrentStage().GenerateItemCode(itemCode);
}
else
{
itemCode *= -1;
}
if (itemCode == NOTHING)
{
Destroy(this.gameObject);
}
else
{
this.GetComponent <Rigidbody2D>().velocity = new Vector2(0.0f, -200.0f);
this.GetComponent <SpriteRenderer>().sprite = spritesItem[itemCode];
}
}
public override bool CanExecute(object parameter)
{
DragEventArgs dragEvent = parameter as DragEventArgs;
ProjectItem draggingItem = dragEvent.Data.GetData(typeof(ProjectItem)) as ProjectItem;
TreeViewItem treeViewItem = Util.FindAncestor <TreeViewItem>((DependencyObject)dragEvent.OriginalSource);
if (treeViewItem == null)
{
return(false);
}
if (treeViewItem.DataContext is ProjectItem item && item.Type != draggingItem.Type)
{
dragEvent.Handled = true;
SignalManager.Get <DetachAdornersSignal>().Dispatch();
dragEvent.Effects = DragDropEffects.None;
return(false);
}
return(true);
}
public TileSet()
{
InitializeComponent();
SignalManager.Get <MouseWheelSignal>().Listener += OnMouseWheel;
SignalManager.Get <ColorPaletteSelectSignal>().Listener += OnColorPaletteSelect;
}
public MainWindow()
{
InitializeComponent();
// Hack to correct the Menu display orientation
_menuDropAlignmentField = typeof(SystemParameters).GetField("_menuDropAlignment", BindingFlags.NonPublic | BindingFlags.Static);
System.Diagnostics.Debug.Assert(_menuDropAlignmentField != null);
EnsureStandardPopupAlignment();
SystemParameters.StaticPropertyChanged += SystemParameters_StaticPropertyChanged;
SignalManager.Get <SetUpWindowPropertiesSignal>().Listener += OnSetUpWindowProperties;
SignalManager.Get <CreateNewElementSignal>().Listener += OnCreateNewElement;
SignalManager.Get <UpdateFolderSignal>().Listener += OnUpdateFolder;
SignalManager.Get <LoadProjectItemSignal>().Listener += OnLoadProjectItem;
SignalManager.Get <DeleteElementSignal>().Listener += OnDeleteElement;
SignalManager.Get <ShowGridSignal>().Listener += OnShowGrid;
SignalManager.Get <HideGridSignal>().Listener += OnHideGrid;
SignalManager.Get <ShowGroupMarksSignal>().Listener += OnShowGroupMarks;
SignalManager.Get <HideGroupMarksSignal>().Listener += OnHideGroupMarks;
SignalManager.Get <MapPaintToolSignal>().Listener += OnMapPaintTool;
SignalManager.Get <MapSelectToolSignal>().Listener += OnMapSelectTool;
SignalManager.Get <MapEraseToolSignal>().Listener += OnMapEraseTool;
SignalManager.Get <CloseProjectSuccessSignal>().Listener += OnCloseProjectSuccess;
SignalManager.Get <ShowLoadingDialogSignal>().Listener += OnShowLoadingDialog;
SignalManager.Get <HideLoadingDialogSignal>().Listener += OnHideLoadingDialog;
// Initialize visibility statte of the toolbars
tbrTileSet.Visibility = Visibility.Collapsed;
tbrMap.Visibility = Visibility.Collapsed;
tbrBanks.Visibility = Visibility.Collapsed;
}
private void ImgSmall_MouseMove(object sender, MouseEventArgs e)
{
if (!_mouseDown)
{
return;
}
if (sender is Image image)
{
if (!image.IsMouseCaptured)
{
return;
}
Point point = e.GetPosition(image);
int x = (int)Math.Floor(point.X / 8);
int y = (int)Math.Floor(point.Y / 8);
if (x < 0 || y < 0 || x >= 8 || y >= 8)
{
return;
}
WriteableBitmap writeableBmp = BitmapFactory.ConvertToPbgra32Format(image.Source as BitmapSource);
SignalManager.Get <SelectedPixelSignal>().Dispatch(writeableBmp.Clone(), new Point(x, y));
}
}
public void AfterLoad(int checkpointNumber, int subobjectives)
{
MenuCameraEffects menuCameraEffects = MenuCameraEffects.instance;
if ((bool)menuCameraEffects && currentLevelNumber >= 0 && currentLevelNumber < levels.Length)
{
string text = levels[currentLevelNumber];
if (text != null && text == "Halloween")
{
menuCameraEffects.ForceDisableOcclusion(forceDisableOcclusion: true);
}
else
{
menuCameraEffects.ForceDisableOcclusion(forceDisableOcclusion: false);
}
}
state = GameState.PlayingLevel;
defaultLight.gameObject.SetActive(value: false);
currentCheckpointNumber = Mathf.Min(checkpointNumber, currentLevel.checkpoints.Length - 1);
currentCheckpointSubObjectives = subobjectives;
currentLevel.BeginLevel();
if (currentLevel.prerespawn != null)
{
currentLevel.prerespawn(currentCheckpointNumber, startingLevel: true);
}
RespawnAllPlayers();
currentLevel.Reset(currentCheckpointNumber, currentCheckpointSubObjectives);
CheckpointLoaded(checkpointNumber);
SignalManager.EndReset();
currentLevel.PostEndReset(currentCheckpointNumber);
}
public void RestartLevel(bool reset = true)
{
if (currentLevel.respawnLocked)
{
return;
}
SignalManager.BeginReset();
currentCheckpointNumber = 0;
currentCheckpointSubObjectives = 0;
if (currentLevel.prerespawn != null)
{
currentLevel.prerespawn(-1, startingLevel: false);
}
RespawnAllPlayers();
if (reset)
{
currentLevel.Reset(currentCheckpointNumber, currentCheckpointSubObjectives);
if (NetGame.isServer)
{
NetSceneManager.ResetLevel(currentCheckpointNumber, currentCheckpointSubObjectives);
}
}
currentLevel.BeginLevel();
SignalManager.EndReset();
if (reset)
{
currentLevel.PostEndReset(currentCheckpointNumber);
}
}
public override void Execute(object parameter)
{
if (_building)
{
return;
}
_building = true;
if (!CheckValidOutputFolder())
{
SignalManager.Get <WriteBuildOutputSignal>().Dispatch("Invalid output folder", OutputMessageType.Error);
_building = false;
return;
}
SignalManager.Get <WriteBuildOutputSignal>().Dispatch("Build started", OutputMessageType.Information);
BuildPalettes();
BuildBanks();
BuildMetaSprites();
BuildBackgrounds();
BuildTilesDefinitions();
SignalManager.Get <WriteBuildOutputSignal>().Dispatch("Build completed", OutputMessageType.Information);
_building = false;
}
private IEnumerator ReloadBundleCoroutine()
{
SignalManager.BeginReset();
if (workshopLevel != null)
{
MenuCameraEffects.instance.RemoveOverride();
workshopLevel.Reload();
}
Time.timeScale = 0f;
SceneManager.LoadScene("Empty");
yield return(null);
yield return(null);
yield return(null);
bundle = FileTools.LoadBundle(workshopLevel.dataPath);
string[] scenePath = bundle.GetAllScenePaths();
SceneManager.LoadScene(Path.GetFileNameWithoutExtension(scenePath[0]));
yield return(null);
SubtitleManager.instance.SetProgress(ScriptLocalization.TUTORIAL.LOADING, 1f, 1f);
yield return(null);
FixupLoadedBundle(SceneManager.GetActiveScene());
bundle.Unload(unloadAllLoadedObjects: false);
currentLevel.BeginLevel();
ResetAllPLayers();
Time.timeScale = 1f;
SignalManager.EndReset();
FixAssetBundleImport();
}
public override void Execute(object parameter)
{
object[] values = (object[])parameter;
string tabID = (string)values[1];
SignalManager.Get <PauseCharacterAnimationSignal>().Dispatch(tabID);
}
public override void Execute(object parameter)
{
string path = parameter as string;
// if there is something to load
if (!string.IsNullOrWhiteSpace(path))
{
// Check if the project file exists in the folder before open the project
string projectFileName = (string)Application.Current.FindResource(_projectFileNameKey);
string fullPath = Path.Combine(path, projectFileName);
if (File.Exists(fullPath))
{
// Extract the name of the folder as our project name
int startIndex = path.LastIndexOf("\\");
string projectName = path.Substring(startIndex + 1, path.Length - startIndex - 1);
LoadProject(path, fullPath, projectName);
}
}
else
{
// We want to capture the browse folder signal to open the project
SignalManager.Get <BrowseFolderSuccessSignal>().Listener += BrowseFolderSuccess;
using (BrowseFolderCommand browseFolder = new BrowseFolderCommand())
{
browseFolder.Execute(null);
}
SignalManager.Get <BrowseFolderSuccessSignal>().Listener += BrowseFolderSuccess;
}
}
/// <summary>
/// Look for enemies and send signal.
/// </summary>
void Update()
{
// Check if not paused.
if (Time.timeScale > 0)
{
bool activated = true;
Collider[] res = Physics.OverlapBox(transform.position, transform.localScale / 2, Quaternion.identity, layerMask);
// Check for entitites with tags Enemy and Spawner
for (int i = 0; i < res.Length; i++)
{
if (res[i].CompareTag("Enemy"))
{
activated = false;
break;
}
if (res[i].CompareTag("Spawner"))
{
// Check if the spawner is still spawnining enemies
if (!res[i].GetComponent <SpawnerController>().Completed)
{
activated = false;
break;
}
}
}
SignalManager.GetInstance().WriteSignal(outSignalId, activated ? 1 : 0);
}
}
public void OnDeactivate()
{
txtPropertyName.Focus();
#region Signals
SignalManager.Get <AddPropertySignal>().Listener -= OnAddProperty;
#endregion
}
public void OnDeactivate()
{
SignalManager.Get <NewAnimationFrameSignal>().Listener -= OnNewAnimationFrame;
SignalManager.Get <DeleteAnimationFrameSignal>().Listener -= OnDeleteAnimationFrame;
FrameViewList.Clear();
spFrames.Children.RemoveRange(0, spFrames.Children.Count - 1);
}
public BuildProjectDialog()
{
InitializeComponent();
#region Signals
SignalManager.Get <WriteBuildOutputSignal>().Listener += OnWriteBuildOutput;
#endregion
}
public Banks()
{
InitializeComponent();
SignalManager.Get <MouseWheelSignal>().Listener += OnMouseWheel;
SignalManager.Get <AddNewTileSetLinkSignal>().Listener += OnAddNewTileSetLink;
SignalManager.Get <CleanupTileSetLinksSignal>().Listener += OnCleanupTileSetLinks;
}
internal static void Init()
{
Configs.Read();
Devices.Initial();
Signal = new SignalManager(
Configs.Signal.Groups.ToList(),
Configs.Signal.Channels.ToList());
}
public override void Execute(object parameter)
{
object[] values = (object[])parameter;
CharacterModel model = (CharacterModel)values[0];
string tabID = (string)values[1];
SignalManager.Get <StopCharacterAnimationSignal>().Dispatch(tabID);
}
public override void Execute(object parameter)
{
DragEventArgs dragEvent = parameter as DragEventArgs;
SignalManager.Get <DetachAdornersSignal>().Dispatch();
dragEvent.Handled = true;
}
