private void PublishPlayerPlasmaDamagedEvent(Plasma plasma) { if (PlayerPlasmaDamagedEvent != null) { PlayerPlasmaDamagedEvent(plasma); } }
//Implement this function to make ExtenderItems persistent. //This function will get called on plasma start for every //ExtenderItem that belonged to this applet, and is still //around. Instantiate the widget to be wrapped in the //ExtenderItem here. public override void InitExtenderItem(Plasma.ExtenderItem item) { //Create a Meter widget and wrap it in the ExtenderItem Plasma.Meter meter = new Plasma.Meter(item) { meterType = Plasma.Meter.MeterType.BarMeterHorizontal, Svg = "widgets/bar_meter_horizontal", Maximum = 100, Value = 0 }; meter.SetMinimumSize(new QSizeF(250, 45)); meter.SetPreferredSize(new QSizeF(250, 45)); //often, you'll want to connect dataengines or set properties //depending on information contained in item.config(). //In this situation that won't be necessary though. item.Widget = meter; //Job names are not unique across plasma restarts (kuiserver //engine just starts with Job1 again), so avoid problems and //just don't give reinstantiated items a name. item.Name = ""; //Show a close button. item.ShowCloseButton(); }
private void OnTriggerStay2D(Collider2D collision) { SlimeDude enemy = collision.GetComponent <SlimeDude>(); Plasma plasma = collision.GetComponent <Plasma>(); ShootingDudeBullet badBullet = collision.GetComponent <ShootingDudeBullet>(); Boss boss = collision.GetComponent <Boss>(); if (enemy != null && timeSinceLastDamage > dmgImmuneTime) { TakeDamage(dmgFromSlime); // Debug.Log("Health amount" + health); SoundManager.instance.RandomsizeSfx(hitSound1, hitSound2); } if (plasma != null && timeSinceLastDamage > dmgImmuneTime) { TakeDamage(dmgFromPlasma); //Debug.Log("Health amount" + health); SoundManager.instance.RandomsizeSfx(hitSound1, hitSound2); } if (badBullet != null && timeSinceLastDamage > dmgImmuneTime) { TakeDamage(dmgFromPlasma); //Debug.Log("Health amount" + health); SoundManager.instance.RandomsizeSfx(hitSound1, hitSound2); } if (boss != null && timeSinceLastDamage > dmgImmuneTime) { TakeDamage(dmgFromPlasma); //Debug.Log("Health amount" + health); SoundManager.instance.RandomsizeSfx(hitSound1, hitSound2); } }
private void AddPlasma(Vector2 position) { Plasma plasma = new Plasma(); plasma.Initialize(GraphicsDevice.Viewport, plasmaTexture, position); plasmas.Add(plasma); }
private void generatePlasma() { #if !CODEGEN PlasmaProxy.Memory.position = PlasmaProxy.generatePlasma(DefaultWidth, DefaultHeight); #endif Plasma.generatePlasma(DefaultWidth, DefaultHeight); }
void OnTriggerEnter2D(Collider2D other) { if (other.tag == "SniperBullet") { bulletScript = other.GetComponent <LineSniperShot>(); DamageJunk(bulletScript.lineSniperShotDamage); } else if (other.tag == "Missile") { homingMissileScript = other.GetComponent <EnemySeekerShot>(); DamageJunk(homingMissileScript.seekerDamage); } else if (other.tag == "Shot") { shotScript = other.GetComponent <ProtoShotPrefab>(); DamageJunk(shotScript.shotDamage); } else if (other.tag == "PhaseBlast") { phaseBlastScript = other.GetComponent <PhaseBlast>(); DamageJunk(phaseBlastScript.phaseBlastDamage); } else if (other.tag == "Plasma") { //damage this plasmaScript = other.GetComponent <Plasma>(); DamageJunk(plasmaScript.plasmaDamage); } else if (other.tag == "ShieldMine") { shieldMineScript = other.GetComponent <ShieldMine>(); DamageJunk(hitPoints); } }
private bool IsValid(Plasma Entity) { if (Entity.UsedDate > Entity.ExpirationDate || Entity.Quantity < 0) { return(false); } return(true); }
public void UpdatePlasma(Plasma plasma) { using (UnitOfWork uow = new UnitOfWork()) { uow.PlasmaRepository.Update(plasma); uow.Save(); } }
void fire_plasma(SceneCharacter3D character) { if (!character.can_fire_plasma()) { return; } Projectiles.Add(Plasma.Fire(character, plasma_prefab)); }
void OnTriggerEnter2D(Collider2D other) { if (other.tag == "Boundary" || other.tag == "MineralPickup" || other.tag == "Capsule" || other.tag == "Edge" || other.tag == "BoostHit") { return; } else if (other.tag == "SniperBullet") { bulletScript = other.GetComponent <LineSniperShot>(); if (bulletScript.teamCount != teamCount) { //Damage the bug DamageThis(bulletScript.lineSniperShotDamage); } } else if (other.tag == "Shot") { shotScript = other.GetComponent <ProtoShotPrefab>(); if (shotScript.teamCount != teamCount) { //Damage this bug DamageThis(shotScript.shotDamage); } } else if (other.tag == "ShieldMine") { mineScript = other.GetComponent <ShieldMine>(); if (mineScript.teamCount != teamCount) { DestroyThis(); } } else if (other.tag == "Missile") { seekerShotScript = other.GetComponent <EnemySeekerShot>(); if (seekerShotScript.teamCount != teamCount) { //Damage DamageThis(seekerShotScript.seekerDamage); } } else if (other.tag == "PhaseBlast") { phaseBlastScript = other.GetComponent <PhaseBlast>(); if (phaseBlastScript.teamCount != teamCount) { DamageThis(phaseBlastScript.phaseBlastDamage); } } else if (other.tag == "Plasma") { plasmaScript = other.GetComponent <Plasma>(); if (plasmaScript.teamCount != teamCount) { DamageThis(plasmaScript.plasmaDamage); } } }
public void CanCreatePlasmaInstance() { IMatter matter = new Plasma("Plasma", 0.01); Assert.NotNull(matter); Assert.Equal("Plasma", matter.Name); Assert.Equal(0.01, matter.Mass); Assert.Equal(States.Plasma, matter.State); }
public override void Shoot() { base.Shoot(); Plasma plasma = Instantiate(plasmaPrefab, firePoint.transform.position, transform.rotation); plasma.moveSpeed = projectileSpeed; plasma.attackRange = attackRange; }
private void button1_Click(object sender, EventArgs e) { string antigen = "0"; bool rh = false; string antibody = "AB"; if (!bloodTypeIsKnown) { antigen = antigenPanel.Controls.OfType <RadioButton>() .FirstOrDefault(r => r.Checked).Text; rh = this.rhPositive.Checked; } else { antigen = donor.bloodType; rh = donor.rh; } if (antigen == "A") { antibody = "B"; } if (antigen == "B") { antibody = "A"; } if (antigen == "AB") { antibody = "0"; } if (antigen == "0") { antibody = "AB"; } bloodType += (rh) ? " Pozitiv" : " Negativ"; int pressure = int.Parse(bloodPressure.Text); int pulse = int.Parse(bloodPulse.Text); float redQ = float.Parse(redQuantity.Text); float trombQ = float.Parse(trombQuantity.Text); float plasmaQ = float.Parse(plasmaQuantity.Text); plasma = new Plasma(antibody, this.donationCenterId, donor.cnp, plasmaQ, DateTime.Now, donor.email); tromb = new Trombocyte(this.donationCenterId, donor.cnp, trombQ, DateTime.Now, donor.email); red = new RedBloodCell(antigen, rh, this.donationCenterId, donor.cnp, redQ, DateTime.Now, donor.email); donation = new Donation(donor.cnp, redQ + trombQ + plasmaQ, pulse, pressure, DateTime.Now, plasmaQ, redQ, trombQ); DialogResult = DialogResult.OK; Close(); }
void OnTriggerEnter2D(Collider2D other) { if (other.tag == "SniperBullet") { bulletScript = other.GetComponent <LineSniperShot>(); if (bulletScript.teamCount != teamCount) { //Damage BlowUp(); } } else if (other.tag == "Shot") { shotScript = other.GetComponent <ProtoShotPrefab>(); if (shotScript.teamCount != teamCount) { //Damage BlowUp(); } } else if (other.tag == "ShieldMine") { mineScript = other.GetComponent <ShieldMine>(); if (mineScript.teamCount != teamCount) { BlowUp(); } } else if (other.tag == "Missile") { seekerShotScript = other.GetComponent <EnemySeekerShot>(); if (seekerShotScript.teamCount != teamCount) { //Damage BlowUp(); } } else if (other.tag == "PhaseBlast") { phaseBlastScript = other.GetComponent <PhaseBlast>(); if (phaseBlastScript.teamCount != teamCount) { //Damage BlowUp(); } } else if (other.tag == "Plasma") { plasmaScript = other.GetComponent <Plasma>(); if (plasmaScript.teamCount != teamCount) { //Damage BlowUp(); } } }
public override void Shoot() { base.Shoot(); Plasma plasma = Instantiate(projectilePrefab, transform.position, transform.rotation).GetComponent <Plasma>(); plasma.team = team; plasma.moveSpeed = projectileSpeed; plasma.damage = projectileDamage; }
public MainPage() { InitializeComponent(); this.Width = 600; this.Height = 600; var i = new Image(); //var s = new WriteableBitmap(600, 600, 96, 96, PixelFormats.Pbgra32, null); var s = new WriteableBitmap(600, 600, PixelFormats.Pbgra32); Plasma.generatePlasma(600, 600); var shift = 0; Action Refresh = delegate { var buffer = Plasma.shiftPlasma(shift); s.Lock(); for (int j = 0; j < buffer.Length; j++) { //Marshal.WriteInt32(s.BackBuffer, j * 4, unchecked((int)(buffer[j] | 0xff000000))); s[j] = unchecked ((int)(buffer[j] | 0xff000000)); } //s.AddDirtyRect(new Int32Rect(0, 0, 600, 600)); s.Invalidate(); s.Unlock(); }; var t = new DispatcherTimer(); t.Tick += delegate { shift++; Refresh(); }; t.Interval = TimeSpan.FromMilliseconds(50); t.Start(); Refresh(); i.Source = s; this.Content = i; }
public FlashPlasmaDocument() { Plasma.generatePlasma(DefaultWidth, DefaultHeight); var shift = 0; var canvas = new IHTMLCanvas(); canvas.width = DefaultWidth; canvas.height = DefaultHeight; var context = (CanvasRenderingContext2D)canvas.getContext("2d"); var xx = context.getImageData(0, 0, DefaultWidth, DefaultHeight); var x = (ImageData)(object)xx; Action AtTick = null; AtTick = delegate { var buffer = Plasma.shiftPlasma(shift); //var x = context.createImageData(DefaultWidth, DefaultHeight); var k = 0; for (int i = 0; i < DefaultWidth; i++) { for (int j = 0; j < DefaultHeight; j++) { var i4 = i * 4; var j4 = j * 4; x.data[i4 + j4 * DefaultWidth + 2] = (byte)((buffer[k] >> (0 * 8)) & 0xff); x.data[i4 + j4 * DefaultWidth + 1] = (byte)((buffer[k] >> (1 * 8)) & 0xff); x.data[i4 + j4 * DefaultWidth + 0] = (byte)((buffer[k] >> (2 * 8)) & 0xff); x.data[i4 + j4 * DefaultWidth + 3] = 0xff; k++; } } context.putImageData(xx, 0, 0, 0, 0, DefaultWidth, DefaultHeight); shift++; Native.Window.requestAnimationFrame += AtTick; }; Native.Window.requestAnimationFrame += AtTick; canvas.AttachToDocument(); }
//private GameObject gun; // private methods private void FireGun() { // create a bullet at the players gun position Plasma bullet = Instantiate(bulletPrefab, bulletParent.transform); bullet.transform.position = transform.position; // get rigidbody and apply speed to bullet Rigidbody2D rb1 = bullet.GetComponent <Rigidbody2D>(); rb1.velocity = Vector2.down * bulletSpeed; }
public void SeparateBloodBag(BloodBag bloodBag, Thrombocyte t, Plasma p, RedBloodCell r) { using (UnitOfWork uow = new UnitOfWork()) { bloodBag.Stage = BloodBagStage.Separation; bloodBag.Status = BloodBagStatus.Destroyed; uow.BloodBagRepository.Update(bloodBag); uow.ThrombocyteRepository.Add(t); uow.PlasmaRepository.Add(p); uow.RedBloodCellRepository.Add(r); uow.Save(); } }
public Plasma Add(DateTime ExpirationDate, DateTime?UsedDate, int Quantity) { Plasma p = new Plasma() { ExpirationDate = ExpirationDate, UsedDate = UsedDate, Quantity = Quantity }; Repository.Add(p); return(p); }
private void enterFrame2() { var shift = getTimer() / 10; Buffer.@lock(); if (RenderMode % 3 == 0) { #if !CODEGEN PlasmaProxy.Memory.position = PlasmaProxy.shiftPlasma(shift); // -- Alchemy palette shifting //alchemyMemory.position = plasmaLib.ToFunc<int, uint>("shiftPlasma")(shift); // -- write the ByteArray straight to the bitmap data Buffer.setPixels(Buffer.rect, PlasmaProxy.Memory); #endif } else { Plasma.shiftPlasma(shift); if (RenderMode % 3 == 1) { var m = new ByteArray(); foreach (var i in Plasma.newPlasma) { m.writeUnsignedInt(i); } m.position = 0; Buffer.setPixels(Buffer.rect, m); } else { // -- AS3.0 palette shifting for (var x = 0; x < DefaultWidth; x++) { for (var y = 0; y < DefaultHeight; y++) { //bmd.setPixel(x, y, 0xff00ff00); //uint c = palette[(plasma[x][y] + shift) % 256]; Buffer.setPixel(x, y, Plasma.newPlasma[x + y * DefaultWidth] | 0xff000000u); } } } } Buffer.unlock(); }
public Page1() { // Request for the permission of type 'System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' failed. InitializeComponent(); var i = new Image(); var s = new WriteableBitmap(600, 600, 96, 96, PixelFormats.Pbgra32, null); Plasma.generatePlasma(600, 600); var shift = 0; Action Refresh = delegate { var buffer = Plasma.shiftPlasma(shift); s.Lock(); for (int j = 0; j < buffer.Length; j++) { Marshal.WriteInt32(s.BackBuffer, j * 4, unchecked ((int)(buffer[j] | 0xff000000))); } s.AddDirtyRect(new Int32Rect(0, 0, 600, 600)); s.Unlock(); }; var t = new DispatcherTimer(); t.Tick += delegate { shift++; Refresh(); }; t.Interval = TimeSpan.FromMilliseconds(10); t.Start(); Refresh(); i.Source = s; this.Content = i; }
private void OnPlayerPlasmaDamagedEvent(Plasma plasma) { //check if player has shields active playerShielded = player.getPlayerInvincible(); if (playerShielded == false && player.getPlayerAlive() == true) { //damage sound FindObjectOfType <AudioManager>().Play("PlayerDamage"); // find plasma damage var damage = plasma.plasmaDamage; //apply damage to player playerHealth -= damage; player.setPlayerHealth(playerHealth); } }
public PlasmaOptionsWindow(Plasma p) { InitializeComponent(); this.SizeToContent = System.Windows.SizeToContent.WidthAndHeight; this.p = p; // this.cg = cg; //Binding ObjectBinding = new Binding("GradientMode"); //ObjectBinding.Source = this.cg; //ObjectBinding.Mode = BindingMode.TwoWay; //Selected_Objects.SetBinding(ComboBox.TextProperty, ObjectBinding); Binding ColorPaletteBinding = new Binding("ColorPalette"); ColorPaletteBinding.Source = this.p; ColorPaletteBinding.Mode = BindingMode.TwoWay; Palettes.SetBinding(ComboBox.TextProperty, ColorPaletteBinding); }
public void run() { while (!that.__stop) { that.shift++; var a = Plasma.shiftPlasma(that.shift); for (int i = 0; i < a.Length; i++) { a[i] = 0xFF000000u | a[i]; } that.buffer.newPixels(); that.paint(that.getGraphics()); Thread.yield(); } }
public void Add(Plasma Entity) { if (IsValid(Entity)) { using (var context = new DatabaseContainer()) { context.PlasmaSet.Add(Entity); try { context.SaveChanges(); } catch (Exception) { throw new ArgumentException("There is already a plasma result with that id"); } } } }
public override void init() { base.resize(DefaultWidth, DefaultHeight); Plasma.generatePlasma(DefaultWidth, DefaultHeight); var pix = Plasma.shiftPlasma(0); this.buffer = new MemoryImageSource(DefaultWidth, DefaultHeight, pix, 0, DefaultWidth); buffer.setAnimated(true); buffer.setFullBufferUpdates(true); new Thread(new SinePlasmaTimer { that = this }).start(); base.resize(DefaultWidth, DefaultHeight); this.img = this.createImage(buffer); }
public ActionResult DonationComplete(AddDonateViewModel model) { if (!ModelState.IsValid) { return(View("AddDonation", model)); } if (model.Plasma < 0 || model.RedCell < 0 || model.Thrombocytes < 0) { ModelState.AddModelError(String.Empty, "Quantity cannot be 0"); return(View("AddDonation", model)); } else if (model.Date < DateTime.Today) { ModelState.AddModelError(String.Empty, "Date cannot be before today"); return(View("AddDonation", model)); } else { DonationAppointment app = _donationAppointmentService.GetById(model.AppointmentId); _donationAppointmentService.Update(app.Id, app.AppointmentDate, app.RequestId, true, app.ProfileId, app.TransfusionCenterId); Plasma p = _plasmaService.Add(model.Date.AddMonths(2), null, model.Plasma); RedCell r = _redCellService.Add(model.Date.AddDays(42), null, model.RedCell); Thrombocytes t = _thrombocytesService.Add(model.Date.AddDays(5), null, model.Thrombocytes); BloodSeparation b = _bloodSeparation.Add(p.Id, r.Id, t.Id); Donation d = _donationService.Add(app.RequestId, model.Plasma + model.RedCell + model.Thrombocytes, model.Date, false, StatusEnum.Preparated, app.ProfileId, b.Id, model.BloodType); LabResult lb = _labResultService.Add(false, false, false, false, false, "None", d.Id); } return(View("AddDonation", model)); }
public Game1() { graphics = new GraphicsDeviceManager(this); Content.RootDirectory = "Content"; //Snow Effect Will Be generated Every 20milisecond //L'effet neige sera generer chaque 20miliseconde snow = new Snow(this, 20); //Create Fire Effect In Disaable Mode //Creer Effet feu en mode desactivé fire = new Fire(this, 0); //Generate Plasma Effect Every right click mouse boutton //generer l'effet plasma a chaque clique sur le bouton droit de la sourie plasma = new Plasma(this, Chimera.Graphics.Effects.Particles.Engine.Controllers.MouseController.MouseButtons.Right); //Fire Effect Will Be Generated After each die of plasma particle //L'effect feu sera generé apres chaque mort d'une particule plasma fire.ApplyEffect(plasma); //Select Default texture for fire effect //Selectione la texture par defaut pour l'effet feu fire.SetDefaultTexture(this); /*For The Default texture you have to inculde resource floder see the second tutorial*/ /*Pour les texture par defaut vous avez a inclure le dossier resource lisez le seconde cours*/ ///Create parameters effect with 300 particle ///Creer les parametre de l'effet avec 300 particule parameters param = new parameters(300); param.direction = 2; ///Create Fire Line Effect Every 100 Milisecond With The Param parameter ///Creer leffet feu sous forme de ligne chaque 100 milisecond avec comme parametre param fireline = new Fire(this, 100, Chimera.Graphics.Enumeration.EParticleType.Line, param); fireline.Position = new Vector2(400, 500); fireline.SetDefaultTexture(this); }
/// <remarks> /// Retrieves the list of actions, if any, for a match /// </remarks> <short> Retrieves the list of actions, if any, for a match </short> public List<QAction> ActionsForMatch(Plasma.QueryMatch match) { return (List<QAction>) interceptor.Invoke("actionsForMatch#", "actionsForMatch(const Plasma::QueryMatch&)", typeof(List<QAction>), typeof(Plasma.QueryMatch), match); }
public void Open(string file) { objects = new List<MapObject>(); BufferReader reader = new BufferReader(file); if (Path.GetExtension(file) != ".adm") { throw new ArgumentException("File does not have *.adm extension."); } if (reader.ReadString() != "ADmapv2") { throw new ArgumentException("Not a valid Adrenaline map file."); } // general map info this.version = reader.ReadByte(); this.gridSize = reader.ReadByte(); // spare slots reader.Skip(15); this.Name = reader.ReadString(); this.Author = reader.ReadString(); this.floorType = reader.ReadByte(); // objects while (reader.HasMore()) { string objectType = reader.ReadString(); int instances = (int)reader.ReadUShort(); for (int i = 0; i < instances; i++) { ushort x = reader.ReadUShort(); ushort y = reader.ReadUShort(); MapObject obj = null; #region Object Creation switch (objectType) { // pickups case "objAbArmor": obj = new BulletArmorPickup(); break; case "objAbIncendary": obj = new BulletIncendiaryPickup(); break; case "objAbDefault": obj = new BulletNormalPickup(); break; case "objAbVelocity": obj = new BulletVelocityPickup(); break; case "objAnades": obj = new GrenadePickup(); break; case "objMedkit": obj = new HealthPickup(); break; case "objAeNormal": obj = new LaserPickup(); break; case "objAmines": obj = new MinePickup(); break; case "objApDisc": obj = new PlasmaDiscPickup(); break; case "objApFragma": obj = new PlasmaFragmaPickup(); break; case "objApHigh": obj = new PlasmaHighPickup(); break; case "objApNormal": obj = new PlasmaNormalPickup(); break; case "objAmNormal": obj = new RocketDualPickup(); break; case "objAmNade": obj = new RocketNukePickup(); break; case "objAcSniper": obj = new SniperPickup(); break; case "objAeSuper": obj = new SuperLaserPickup(); break; // static case "objSpawn": obj = new AllSpawn(); break; case "objFlagBlue": obj = new BlueFlag(); break; case "objFlagRed": obj = new RedFlag(); break; case "objTBlueSpawn": obj = new BlueSpawn(); break; case "objTRedSpawn": obj = new RedSpawn(); break; case "objLevelMine": obj = new LevelMine(); break; case "objTeleportDest": obj = new TeleportDestination(); break; case "objTeleportSrc": obj = new TeleportSource(); break; case "objStaticLight": obj = new Light(reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte()); break; // Walls case "objBlockWallBlocks": obj = new BlocksWall(); break; case "objBlockBrick": obj = new BrickWall(); break; case "objCube": obj = new CompanionCube(); break; case "objCompanion": obj = new Crate(); break; case "objBlockWall": obj = new GreyWall(); break; case "objBlockIceWall": obj = new IceWall(); break; case "objBlockLight": obj = new LightWall(); break; case "objBlockLightWall": obj = new LightWall2(); break; case "objBlockOld": obj = new OldWall(); break; case "objBlockRusty": obj = new RustyWall(); break; case "objBlockStripeWall": obj = new StripeWall(); break; case "objBlockWallpaper": obj = new WallpaperWall(); break; case "objBlockCrate": obj = new WoodWall(); break; // weapons case "objAssault": obj = new Assault(); break; case "objSawnOff": obj = new Curveshot(); break; case "objLaserRifle": obj = new Laser(); break; case "objLauncher": obj = new Launcher(); break; case "objMinigun": obj = new Minigun(); break; case "objPistol": obj = new IceWall(); break; case "Pistol": obj = new LightWall(); break; case "objPlasma": obj = new Plasma(); break; case "objShotgun": obj = new Shotgun(); break; case "objSMG": obj = new SMG(); break; case "objSniper": obj = new Sniper(); break; default: // no known object... better read bytes anyway reader.ReadUShort(); reader.ReadUShort(); break; } #endregion Object Creation if (obj != null) { obj.X = x; obj.Y = y; objects.Add(obj); } } } }
/// <remarks> /// Copy constructor /// </remarks> <short> Copy constructor </short> public QueryMatch(Plasma.QueryMatch other) : this((Type) null) { CreateProxy(); interceptor.Invoke("QueryMatch#", "QueryMatch(const Plasma::QueryMatch&)", typeof(void), typeof(Plasma.QueryMatch), other); }
/// <remarks> /// Connects a source to an object for data updates. The object must /// have a slot with the following signature: /// dataUpdated(stringsourceName, const Plasma.DataEngine.Data &data) /// The data is a QHash of QVariants keyed by string names, allowing /// one data source to provide sets of related data. /// <param> name="source" the name of the data source /// </param><param> name="visualization" the object to connect the data source to /// </param><param> name="pollingInterval" the frequency, in milliseconds, with which to check for updates; /// a value of 0 (the default) means to update only /// when there is new data spontaneously generated /// (e.g. by the engine); any other value results in /// periodic updates from this source. This value is /// per-visualization and can be handy for items that require /// constant updates such as scrolling graphs or clocks. /// If the data has not changed, no update will be sent. /// </param><param> name="intervalAlignment" the number of ms to align the interval to /// </param></remarks> <short> Connects a source to an object for data updates.</short> public void ConnectSource(string source, QObject visualization, uint pollingInterval, Plasma.IntervalAlignment intervalAlignment) { interceptor.Invoke("connectSource$#$$", "connectSource(const QString&, QObject*, uint, Plasma::IntervalAlignment) const", typeof(void), typeof(string), source, typeof(QObject), visualization, typeof(uint), pollingInterval, typeof(Plasma.IntervalAlignment), intervalAlignment); }
public void SetImmutability(Plasma.ImmutabilityType immutable) { applet.SetImmutability(immutable); }
/// <remarks> /// Connects an object to this DataContainer. /// May be called repeatedly for the same visualization without /// side effects /// <param> name="visualization" the object to connect to this DataContainer /// </param><param> name="pollingInterval" the time in milliseconds between updates /// </param><param> name="alignment" the clock position to align updates to /// </param></remarks> <short> Connects an object to this DataContainer.</short> public void ConnectVisualization(QObject visualization, uint pollingInterval, Plasma.IntervalAlignment alignment) { interceptor.Invoke("connectVisualization#$$", "connectVisualization(QObject*, uint, Plasma::IntervalAlignment)", typeof(void), typeof(QObject), visualization, typeof(uint), pollingInterval, typeof(Plasma.IntervalAlignment), alignment); }
public void InstantiatePlasma(SceneCharacter3D character) { Projectiles.Add(Plasma.Fire(character, PlasmaPrefab)); }
/// <remarks> /// Loads an Applet script engine for the given language. /// <param> name="language" the language to load for /// </param><param> name="runner" the Plasma.AbstractRunner for this script /// </param></remarks> <return> pointer to the RunnerScript or 0 on failure; the caller is responsible /// for the return object which will be parented to the AbstractRunner /// </return> /// <short> Loads an Applet script engine for the given language.</short> public static Plasma.RunnerScript LoadScriptEngine(string language, Plasma.AbstractRunner runner) { return (Plasma.RunnerScript) staticInterceptor.Invoke("loadScriptEngine$#", "loadScriptEngine(const QString&, Plasma::AbstractRunner*)", typeof(Plasma.RunnerScript), typeof(string), language, typeof(Plasma.AbstractRunner), runner); }
/// <remarks> /// Starts a standard animation on a QGraphicsItem. /// @arg item the item to animate in some fashion /// @arg anim the type of animation to perform /// </remarks> <return> the id of the animation /// </return> /// <short> Starts a standard animation on a QGraphicsItem.</short> public int AnimateItem(IQGraphicsItem item, Plasma.Animator.Animation anim) { return (int) interceptor.Invoke("animateItem#$", "animateItem(QGraphicsItem*, Plasma::Animator::Animation)", typeof(int), typeof(IQGraphicsItem), item, typeof(Plasma.Animator.Animation), anim); }
/// <remarks> /// Converts a location to the direction facing it. Handy for figuring out which way to collapse /// a popup or to point arrows at the item itself. /// <param> name="location" the location of the container the element will appear in /// </param></remarks> <return> the visual direction the element should be oriented in /// </return> /// <short> Converts a location to the direction facing it.</short> public static Plasma.Direction LocationToInverseDirection(Plasma.Location location) { return (Plasma.Direction) staticInterceptor.Invoke("locationToInverseDirection$", "locationToInverseDirection(Plasma::Location)", typeof(Plasma.Direction), typeof(Plasma.Location), location); }
public int AnimateElement(IQGraphicsItem arg1, Plasma.Animator.Animation arg2) { return (int) interceptor.Invoke("animateElement#$", "animateElement(QGraphicsItem*, Plasma::Animator::Animation)", typeof(int), typeof(IQGraphicsItem), arg1, typeof(Plasma.Animator.Animation), arg2); }
/// <remarks> /// Starts a standard animation on a QGraphicsItem. /// @arg item the item to animate in some fashion /// @arg anim the type of animation to perform /// </remarks> <return> the id of the animation /// </return> /// <short> Starts a standard animation on a QGraphicsItem.</short> public int MoveItem(IQGraphicsItem item, Plasma.Animator.Movement movement, QPoint destination) { return (int) interceptor.Invoke("moveItem#$#", "moveItem(QGraphicsItem*, Plasma::Animator::Movement, const QPoint&)", typeof(int), typeof(IQGraphicsItem), item, typeof(Plasma.Animator.Movement), movement, typeof(QPoint), destination); }
/// <remarks> /// Loads an appropriate PackageStructure for the given language and type /// <param> name="language" the language to load the PackageStructure for /// </param><param> name="type" the component type /// </param></remarks> <return> a guarded PackageStructure pointer /// </return> /// <short> Loads an appropriate PackageStructure for the given language and type </short> public static Plasma.PackageStructure PackageStructure(string language, Plasma.ComponentType type) { return (Plasma.PackageStructure) staticInterceptor.Invoke("packageStructure$$", "packageStructure(const QString&, Plasma::ComponentType)", typeof(Plasma.PackageStructure), typeof(string), language, typeof(Plasma.ComponentType), type); }
public virtual void InitExtenderItem(Plasma.ExtenderItem item) { Console.WriteLine("Missing implementation of initExtenderItem in the applet {0}!", item.Config().ReadEntry("SourceAppletPluginName", "")); Console.WriteLine("Any applet that uses extenders should implement initExtenderItem to instantiate a widget."); }
void OnTriggerEnter2D(Collider2D other) { if (other.tag == "Boundary" || other.tag == "MineralPickup" || other.tag == "Capsule" || other.tag == "Edge" || other.tag == "Map" || other.tag == "Ibeam") { return; } else if (other.tag == "RocketAmmo") { rocketScript = other.GetComponent <RemoteLauncherShot>(); if (rocketScript.teamCount != teamCount) { //Debug.Log(teamCount + " |other: " + rocketScript.teamCount); if (hitCount > 1) { Destroy(this.gameObject); } else { hitCount++; } } } else if (other.tag == "SniperBullet") { bulletScript = other.GetComponent <LineSniperShot>(); if (bulletScript.teamCount != teamCount) { //Debug.Log(teamCount + " |other: " + bulletScript.teamCount); if (hitCount > 1) { Destroy(this.gameObject); } else { hitCount++; } } } else if (other.tag == "Missile") { homingMissileScript = other.GetComponent <EnemySeekerShot>(); if (homingMissileScript.teamCount != teamCount) { if (hitCount > 1) { Destroy(this.gameObject); } else { hitCount++; } } } else if (other.tag == "Shot") { shotScript = other.GetComponent <ProtoShotPrefab>(); if (shotScript.teamCount != teamCount) { //Debug.Log(teamCount + " |other: " + shotScript.teamCount); if (hitCount > 1) { Destroy(this.gameObject); } else { hitCount++; } } } else if (other.tag == "Player1(Black)" || other.tag == "Player2(White)" || other.tag == "Player3" || other.tag == "Player4") { enemyHealthScript = other.GetComponent <PlayerHealth>(); if (enemyHealthScript.teamCount != teamCount) { enemyHealthScript.Damage(mineDamage, false); Destroy(this.gameObject); } } else if (other.tag == "PlayerPhysicsCollider") { enemyHealthScript = other.GetComponentInParent <PlayerHealth>(); if (enemyHealthScript.teamCount != teamCount) { enemyHealthScript.Damage(mineDamage, false); Destroy(this.gameObject); } } else if (other.tag == "Asteroid") { asteroidScript = other.GetComponent <Asteroid>(); asteroidScript.DamageAsteroid(mineDamage); Destroy(this.gameObject); } else if (other.tag == "Plasma") { plasmaScript = other.GetComponent <Plasma>(); if (plasmaScript.teamCount != teamCount) { if (hitCount > 1) { Destroy(this.gameObject); } else { hitCount++; } } } }
/// <remarks> /// Sets the preferred aspect ratio mode for placement and resizing /// </remarks> <short> Sets the preferred aspect ratio mode for placement and resizing </short> public void SetAspectRatioMode(Plasma.AspectRatioMode arg1) { applet.SetAspectRatioMode(arg1); }
/// <remarks> /// Sets the type of match this action represents. /// </remarks> <short> Sets the type of match this action represents.</short> public void SetType(Plasma.QueryMatch.TypeOf type) { interceptor.Invoke("setType$", "setType(Plasma::QueryMatch::Type)", typeof(void), typeof(Plasma.QueryMatch.TypeOf), type); }
/// <remarks> /// Loads an DataEngine script engine for the given language. /// <param> name="language" the language to load for /// </param><param> name="dataEngine" the Plasma.DataEngine for this script; /// </param></remarks> <return> pointer to the DataEngineScript or 0 on failure; the caller is responsible /// for the return object which will be parented to the DataEngine /// </return> /// <short> Loads an DataEngine script engine for the given language.</short> public static Plasma.DataEngineScript LoadScriptEngine(string language, Plasma.DataEngine dataEngine) { return (Plasma.DataEngineScript) staticInterceptor.Invoke("loadScriptEngine$#", "loadScriptEngine(const QString&, Plasma::DataEngine*)", typeof(Plasma.DataEngineScript), typeof(string), language, typeof(Plasma.DataEngine), dataEngine); }
/// <remarks> /// Causes an animated show; requires compositing to work, otherwise /// the dialog will simply show. /// </remarks> <short> Causes an animated show; requires compositing to work, otherwise the dialog will simply show.</short> public void AnimatedShow(Plasma.Direction direction) { interceptor.Invoke("animatedShow$", "animatedShow(Plasma::Direction)", typeof(void), typeof(Plasma.Direction), direction); }
/// <remarks> /// Requests this match to activae using the given context /// <param> name="context" the context to use in conjunction with this run /// </param> @sa AbstractRunner.Run /// </remarks> <short> Requests this match to activae using the given context </short> public void Run(Plasma.RunnerContext context) { interceptor.Invoke("run#", "run(const Plasma::RunnerContext&) const", typeof(void), typeof(Plasma.RunnerContext), context); }
/// <remarks> /// Registers a package described by the given desktop file /// @arg the full path to the desktop file (must be KPluginInfo compatible) /// </remarks> <return> true on success, false on failure /// </return> /// <short> Registers a package described by the given desktop file </short> public static bool RegisterPackage(Plasma.PackageMetadata data, string iconPath) { return (bool) staticInterceptor.Invoke("registerPackage#$", "registerPackage(const Plasma::PackageMetadata&, const QString&)", typeof(bool), typeof(Plasma.PackageMetadata), data, typeof(string), iconPath); }
/// <remarks> /// Constructs a PossibleMatch associated with a given RunnerContext /// and runner. /// <param> name="search" the RunnerContext this match belongs to /// </param><param> name="runner" the runner this match belongs to /// </param></remarks> <short> Constructs a PossibleMatch associated with a given RunnerContext and runner.</short> public QueryMatch(Plasma.AbstractRunner runner) : this((Type) null) { CreateProxy(); interceptor.Invoke("QueryMatch#", "QueryMatch(Plasma::AbstractRunner*)", typeof(void), typeof(Plasma.AbstractRunner), runner); }
/// <remarks> /// Construct a Package object. /// @arg packagePath full path to the package directory /// @arg structure the package structure describing this package /// </remarks> <short> Construct a Package object.</short> public Package(string packagePath, Plasma.PackageStructure structure) : this((Type) null) { CreateProxy(); interceptor.Invoke("Package$?", "Package(const QString&, KSharedPtr<Plasma::PackageStructure>)", typeof(void), typeof(string), packagePath, typeof(Plasma.PackageStructure), structure); }
/// <remarks> /// Connects all currently existing sources to an object for data updates. /// The object must have a slot with the following signature: /// SLOT("dataUpdated(string,Plasma.DataEngine.Data)") /// The data is a QHash of QVariants keyed by string names, allowing /// one data source to provide sets of related data. /// This method may be called multiple times for the same visualization /// without side-effects. This can be useful to change the pollingInterval. /// Note that this method does not automatically connect sources that /// may appear later on. Connecting and responding to the sourceAdded sigal /// is still required to achieve that. /// <param> name="visualization" the object to connect the data source to /// </param><param> name="pollingInterval" the frequency, in milliseconds, with which to check for updates; /// a value of 0 (the default) means to update only /// when there is new data spontaneously generated /// (e.g. by the engine); any other value results in /// periodic updates from this source. This value is /// per-visualization and can be handy for items that require /// constant updates such as scrolling graphs or clocks. /// If the data has not changed, no update will be sent. /// </param><param> name="intervalAlignment" the number of ms to align the interval to /// </param></remarks> <short> Connects all currently existing sources to an object for data updates.</short> public void ConnectAllSources(QObject visualization, uint pollingInterval, Plasma.IntervalAlignment intervalAlignment) { interceptor.Invoke("connectAllSources#$$", "connectAllSources(QObject*, uint, Plasma::IntervalAlignment) const", typeof(void), typeof(QObject), visualization, typeof(uint), pollingInterval, typeof(Plasma.IntervalAlignment), intervalAlignment); }
public static bool CreatePackage(Plasma.PackageMetadata metadata, string source, string destination) { return (bool) staticInterceptor.Invoke("createPackage#$$", "createPackage(const Plasma::PackageMetadata&, const QString&, const QString&)", typeof(bool), typeof(Plasma.PackageMetadata), metadata, typeof(string), source, typeof(string), destination); }
/// <remarks> /// Adds an already constructed data source. The DataEngine takes /// ownership of the DataContainer object. The objectName of the source /// is used for the source name. /// <param> name="source" the DataContainer to add to the DataEngine /// </param></remarks> <short> Adds an already constructed data source.</short> protected void AddSource(Plasma.DataContainer source) { interceptor.Invoke("addSource#", "addSource(Plasma::DataContainer*)", typeof(void), typeof(Plasma.DataContainer), source); }
/// <remarks> /// Runs a given match /// @arg match the match to be executed /// </remarks> <short> Runs a given match @arg match the match to be executed </short> public void Run(Plasma.QueryMatch match) { interceptor.Invoke("run#", "run(const Plasma::QueryMatch&)", typeof(void), typeof(Plasma.QueryMatch), match); }
/// <remarks> /// Sets the preferred aspect ratio mode for placement and resizing /// </remarks> <short> Sets the preferred aspect ratio mode for placement and resizing </short> public void SetAspectRatioMode(Plasma.AspectRatioMode mode) { interceptor.Invoke("setAspectRatioMode$", "setAspectRatioMode(Plasma::AspectRatioMode)", typeof(void), typeof(Plasma.AspectRatioMode), mode); }
/// <remarks> /// </remarks> <return> the scaling factor (0..1) for a ZoomLevel /// </return> /// <short> </short> public static double ScalingFactor(Plasma.ZoomLevel level) { return (double) staticInterceptor.Invoke("scalingFactor$", "scalingFactor(Plasma::ZoomLevel)", typeof(double), typeof(Plasma.ZoomLevel), level); }
/// <remarks> /// Sets the applet associated with this AppletScript /// </remarks> <short> Sets the applet associated with this AppletScript </short> public void SetApplet(Plasma.Applet applet) { interceptor.Invoke("setApplet#", "setApplet(Plasma::Applet*)", typeof(void), typeof(Plasma.Applet), applet); }
/// <remarks> /// Starts a custom animation, preventing the need to create a timeline /// with its own timer tick. /// @arg frames the number of frames this animation should persist for /// @arg duration the length, in milliseconds, the animation will take /// @arg curve the curve applied to the frame rate /// @arg receive the object that will handle the actual animation /// @arg method the method name of slot to be invoked on each update. /// It must take a qreal. So if the slot is animate(qreal), /// pass in "animate" as the method parameter. /// It has an optional integer paramenter that takes an /// integer that reapresents the animation id, useful if /// you want to manage multiple animations with a sigle slot /// </remarks> <return> an id that can be used to identify this animation. /// </return> /// <short> Starts a custom animation, preventing the need to create a timeline with its own timer tick.</short> public int CustomAnimation(int frames, int duration, Plasma.Animator.CurveShape curve, QObject receiver, string method) { return (int) interceptor.Invoke("customAnimation$$$#$", "customAnimation(int, int, Plasma::Animator::CurveShape, QObject*, const char*)", typeof(int), typeof(int), frames, typeof(int), duration, typeof(Plasma.Animator.CurveShape), curve, typeof(QObject), receiver, typeof(string), method); }