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);
}
