private void setPositionForButtons(ObjectHolder holder)
{
int count = holder.activeSkills.Length + holder.auraSkills.Length + holder.belt.Length;
if (holder.normalHit != null)
count ++;
int x = 0;
count--;
RectTransform objectRectTransform = holder.canvas.GetComponent<RectTransform>();
int height = (int)objectRectTransform.rect.height;
setPositionForButtonIcon(x, height, count, holder.normalHit);
x++;
foreach (ButtonIcon btn in holder.activeSkills)
{
setPositionForButtonIcon(x, height, count, btn);
x++;
}
foreach (ButtonIcon btn in holder.auraSkills)
{
setPositionForButtonIcon(x, height, count, btn);
x++;
}
foreach (ButtonIcon btn in holder.belt)
{
setPositionForButtonIcon(x, height, count, btn);
x++;
}
}
public StatusEffectControl(GameInstance owner, Action<StatusEffectEntity2> onAttach, Action<StatusEffectEntity2> onDetach)
{
this.objectHolder = owner;
this.stat = owner.Stat;
this.onAttach = onAttach;
this.onDetach = onDetach;
}
void OnTriggerStay2D(Collider2D other){
if (other.gameObject.CompareTag ("Search")) {
objectPresent = true;
thisObject = other.gameObject;
objectScript = thisObject.GetComponent<ObjectHolder>();
}
}
public Status(ObjectHolder owner, Stat stat, System.Type statusType)
{
this.StatusType = statusType;
this.stat = stat;
buffControl = new BuffControl(owner, stat);
values = new Dictionary<Enum, float>();
minValues = new Dictionary<Enum, float>();
maxValues = new Dictionary<Enum, float>();
minStats = new Dictionary<Enum, Enum>();
maxStats = new Dictionary<Enum, Enum>();
}
public static ObjectHolder Instance()
{
if (!objectHolder)
{
objectHolder = FindObjectOfType(typeof(ObjectHolder)) as ObjectHolder;
if (!objectHolder)
{
GameObject uiHolderObject = new GameObject("ObjectHolder");
uiHolderObject.AddComponent<ObjectHolder>();
objectHolder = uiHolderObject.GetComponent<ObjectHolder>();
}
}
return objectHolder;
}
void OnBurialBladeUnsnap(ObjectHolder holder)
{
if (!handleController)
{
InitializeHolder(holder);
}
if (handleController)
{
if (holder == handleController.burialHolder)
{
handleController.DeactivateColliders();
sparks.Play();
burialBladeSnap.Play();
}
}
}
/// <summary>Indexer to update local member variables</summary>
/// <remarks>This indexer is used by the Wilson WilsonORWrapper</remarks>
object IObjectHelper.this[string memberName]
{
get {
switch (memberName)
{
case "_userid": return(_userid);
case "_username": return(_username);
case "_password": return(_password);
case "_departmentid": return(_departmentid);
case "_department": return(_department);
case "_managerDepartments": return(_managerDepartments);
default: throw new Exception(string.Format("Mapping: IObjectHelper Get is missing member case {0}", memberName));
}
}
set {
//handle null values
if (value == null)
{
return;
}
switch (memberName)
{
case "_userid": _userid = (int)value; break;
case "_username": _username = (string)value; break;
case "_password": _password = (string)value; break;
case "_departmentid": _departmentid = (Nullable <int>)value; break;
case "_department": _department = (ObjectHolder <Department>)value; break;
case "_managerDepartments": _managerDepartments = (IList <Department>)value; break;
default: throw new Exception(string.Format("Mapping: IObjectHelper Set is missing member case {0}", memberName));
}
}
}
static Status2<HeroStatusType> InitStatus(ObjectHolder owner, Stat2 stat, SubClassEntity subClassEntity)
{
var blockAtt1 = TableLoader.GetTable<BlockEntity2>().Get(subClassEntity.attackBlock1);
var blockAtt2 = TableLoader.GetTable<BlockEntity2>().Get(subClassEntity.attackBlock2);
Status2<HeroStatusType> ret = new Status2<HeroStatusType>(stat,
new Status2<HeroStatusType>.Init(HeroStatusType.hp, 0, HeroStatType.maxHP, 0),
new Status2<HeroStatusType>.Init(HeroStatusType.ap, 0, HeroStatType.maxAP, 0),
new Status2<HeroStatusType>.Init(HeroStatusType.mp, 0, HeroStatType.maxMP, 0),
new Status2<HeroStatusType>.Init(HeroStatusType.attack1CP, 0, blockAtt1.maxCP1, 0),
new Status2<HeroStatusType>.Init(HeroStatusType.attack1ChargeCount, 0, blockAtt1.maxChargeCount, 0),
new Status2<HeroStatusType>.Init(HeroStatusType.attack2CP, 0, blockAtt2.maxCP1, 0),
new Status2<HeroStatusType>.Init(HeroStatusType.attack2ChargeCount, 0, blockAtt2.maxChargeCount, 0),
new Status2<HeroStatusType>.Init(HeroStatusType.speed, 0, HeroStatType.moveSpeed, 0));
return ret;
}
protected override void Initialize()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
Device = graphics.GraphicsDevice;
//Initialize game info:
graphics.PreferredBackBufferWidth = 1000;
graphics.PreferredBackBufferHeight = 650;
graphics.IsFullScreen = false;
graphics.ApplyChanges();
Window.Title = "Adventure Game 2.0";
IsMouseVisible = true;
//Initialize the static classes:
ObjectHolder.Initialize();
KeyboardManager.Initialize();
base.Initialize();
}
public void Init()
{
inGame = true;
CenterMouse.Instance();
modalPanel = ModalPanel.Instance();
objectHolder = ObjectHolder.Instance();
objectHolder.tutorialPanel.SetActive(false);
Inventory.items.Clear();
foreach (Entity e in objectsToAddAtStart)
{
Inventory.Add(e);
}
modalPanel.Register(new PopUpMessage(Localizer.Instance().GetText("storySoFar"), "storySoFarComment", showTutorialAction));
OnPauseMenu();
}
private void fireChainGun(float offsetSpeed, float maxOffset, float BulletRng)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.ChainGunBullet_lvl_1)], ProjectileSpawnPoint + (TurretGameObject.transform.right * chainGunOffset), TurretGameObject.transform.rotation * Quaternion.Euler(0, 0, Random.Range(BulletRng, -BulletRng)));
if (chainGunOffsetUp)
{
chainGunOffset += offsetSpeed;
}
else
{
chainGunOffset -= offsetSpeed;
}
if (chainGunOffset >= maxOffset)
{
chainGunOffsetUp = false;
}
if (chainGunOffset <= -maxOffset)
{
chainGunOffsetUp = true;
}
}
protected void SpawnAndSnap(string spawnedItemID, ObjectHolder holder)
{
ItemPhysic spawnedItemData = Catalog.GetData <ItemPhysic>(spawnedItemID, true);
//Debug.Log("[HoldingBag][Fetch][Spawn] Item Categories: " + spawnedItemData.categoryPath + ", Item Name: " + spawnedItemData.displayName);
if (spawnedItemData == null)
{
return;
}
else
{
Item thisSpawnedItem = spawnedItemData.Spawn(true);
if (!thisSpawnedItem.gameObject.activeInHierarchy)
{
thisSpawnedItem.gameObject.SetActive(true);
}
holder.Snap(thisSpawnedItem);
return;
}
}
private void fireChainGun(int _level, float offsetSpeed, float maxOffset, float _BulletRng, Vector3 _ProjectileSpawnPoint, GameObject _TurretGameObject)
{
GameObject _bullet = null;
switch (_level)
{
case (1):
_bullet = ObjectHolder._Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.ChainGunBullet_lvl_1)];
break;
case (2):
_bullet = ObjectHolder._Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.ChainGunBullet_lvl_2)];
break;
case (3):
_bullet = ObjectHolder._Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.ChainGunBullet_lvl_3)];
break;
default:
Debug.LogError("fireChain gun did not recive a level of 1, 2 or 3.");
return;
}
Instantiate(_bullet, _ProjectileSpawnPoint + (_TurretGameObject.transform.right * chainGunOffset), _TurretGameObject.transform.rotation * Quaternion.Euler(0, 0, Random.Range(_BulletRng, -_BulletRng)));
if (chainGunOffsetUp)
{
chainGunOffset += offsetSpeed;
}
else
{
chainGunOffset -= offsetSpeed;
}
if (chainGunOffset >= maxOffset)
{
chainGunOffsetUp = false;
}
if (chainGunOffset <= -maxOffset)
{
chainGunOffsetUp = true;
}
}
/// <summary>Indexer to update local member variables</summary>
/// <remarks>This indexer is used by the Wilson WilsonORWrapper</remarks>
object IObjectHelper.this[string memberName]
{
get {
switch (memberName)
{
case "_departmentid": return(_departmentid);
case "_departmentMember": return(_departmentMember);
case "_managerUserid": return(_managerUserid);
case "_managerUser": return(_managerUser);
case "_users": return(_users);
default: throw new Exception(string.Format("Mapping: IObjectHelper Get is missing member case {0}", memberName));
}
}
set {
//handle null values
if (value == null)
{
return;
}
switch (memberName)
{
case "_departmentid": _departmentid = (int)value; break;
case "_departmentMember": _departmentMember = (string)value; break;
case "_managerUserid": _managerUserid = (int)value; break;
case "_managerUser": _managerUser = (ObjectHolder <User>)value; break;
case "_users": _users = (IList <User>)value; break;
default: throw new Exception(string.Format("Mapping: IObjectHelper Set is missing member case {0}", memberName));
}
}
}
void OnBurialBladeSnap(ObjectHolder holder)
{
if (!handleController)
{
InitializeHolder(holder);
}
if (handleController)
{
if (holder == handleController.burialHolder)
{
handleController.ActivateColliders();
sparks.Play();
burialBladeSnap.Play();
if (!handleController.isExtended)
{
handleController.isChanging = true;
}
}
}
}
public T Pull(object UserData = null)
{
T obj = null;
obj = ObjectHolder.Pull(UserData);
if (obj == null)
{
if (Factory != null)
{
obj = Factory.Instantiate(UserData);
}
}
else
{
obj.GoOutOfPool();
Factory.BeforeGetFromPool(obj, UserData);
}
return(obj);
}
void AssignHiddenObjects() //Method select objects from the hiddenobjects list which should be hidden
{
ObjectHolder objectHolder = Instantiate(objectHolderPrefab, Vector3.zero, Quaternion.identity);
totalHiddenObjectsFound = 0; //set it to 0 by default
activeHiddenObjectList.Clear(); //clear the list by default
gameStatus = GameStatus.PLAYING; //set game status to playing
UIManager.instance.TimerText.text = "" + timeLimit; //set the timer text of UIManager
currentTime = timeLimit; //set the currentTime to timeLimit
for (int i = 0; i < objectHolder.HiddenObjectList.Count; i++) //loop through all the hiddenObjects in the hiddenObjectList
{
//deacivate collider, as we only want selected hidden objects to have collider active
objectHolder.HiddenObjectList[i].hiddenObj.GetComponent <Collider2D>().enabled = false;
}
int k = 0; //int to keep count
while (k < maxHiddenObjectToFound) //we check while k is less that maxHiddenObjectToFound, keep looping
{
//we randomly select any number between 0 to hiddenObjectList.Count
int randomNo = UnityEngine.Random.Range(0, objectHolder.HiddenObjectList.Count);
//then we check is the makeHidden bool of that hiddenObject is false
if (!objectHolder.HiddenObjectList[randomNo].makeHidden)
{
//we are setting the object name similar to index, because we are going to use index to identify the tapped object
//and this index will help us to deactive the hidden object icon from the UI
objectHolder.HiddenObjectList[randomNo].hiddenObj.name = "" + k; //set their name to index
objectHolder.HiddenObjectList[randomNo].makeHidden = true; //if false, then we set it to true
//activate its collider, so we can detect it on tap
objectHolder.HiddenObjectList[randomNo].hiddenObj.GetComponent <Collider2D>().enabled = true;
activeHiddenObjectList.Add(objectHolder.HiddenObjectList[randomNo]); //add the hidden object to the activeHiddenObjectList
k++; //and increase the k
}
}
UIManager.instance.PopulateHiddenObjectIcons(activeHiddenObjectList); //send the activeHiddenObjectList to UIManager
gameStatus = GameStatus.PLAYING; //set gamestatus to Playing
}
public void BasicTest()
{
var holder = new ObjectHolder();
var count = TestRunnerInfo.IsBuildAgent() ? 100 : 1000;
var objects = Enumerable.Range(0, count).Select(i => i.ToString()).ToArray();
var holds = new HashSet <IDisposable>();
foreach (var o in objects)
{
holds.Add(holder.Hold(o));
}
holder.IsEmpty.Should().BeFalse();
// HashSet randomizes the order of disposal
foreach (var hold in holds)
{
hold.Dispose();
}
holder.IsEmpty.Should().BeTrue();
}
public void InitButtons(Action[] active, Action[] aura, Action[] belt, ObjectHolder holder)
{
if (holder.normalHit == null) {
Action normal = new Action();
normal.mana = "0";
normal.type = "hit";
normal.name = "Hit";
normal.id = "4";
holder.normalHit = new ButtonIcon(holder.canvas, normal);
}
if (holder.activeSkills.Length != active.Length) {
holder.activeSkills = new ButtonIcon[active.Length];
int x = 0;
foreach (Action action in active)
{
holder.activeSkills[x] = new ButtonIcon(holder.canvas, action);
x++;
}
}
if (holder.auraSkills.Length != aura.Length) {
holder.auraSkills = new ButtonIcon[aura.Length];
int x = 0;
foreach (Action action in aura)
{
holder.auraSkills[x] = new ButtonIcon(holder.canvas, action);
x++;
}
}
if (holder.belt.Length != belt.Length) {
holder.belt = new ButtonIcon[belt.Length];
int x = 0;
foreach (Action action in belt)
{
holder.belt[x] = new ButtonIcon(holder.canvas, action);
x++;
}
}
setPositionForButtons(holder);
}
public Task <T> GetSingleAsync <T, TKey>(TKey key) where T : IStatefulObject <TKey>
{
Guard.NotNull(key, nameof(key));
lock (lockObject)
{
if (statesCache.TryGetValue <ObjectHolder <T, TKey> >(key, out var stateObj))
{
return(stateObj.ActivateAsync());
}
var state = (T)services.GetService(typeof(T));
stateObj = new ObjectHolder <T, TKey>(state, key);
statesCache.CreateEntry(key)
.SetValue(stateObj)
.SetAbsoluteExpiration(CacheDuration)
.Dispose();
return(stateObj.ActivateAsync());
}
}
public void SetState(ObjectHolder holder, string state)
{
bool interactable = true;
if (state == "It is not your turn") {
interactable = true;
}
if (holder.normalHit != null) {
holder.normalHit.getButton().interactable = interactable;
holder.normalHit.setIconInvisible(interactable);
}
foreach (ButtonIcon btn in holder.activeSkills) {
btn.getButton().interactable = interactable;
btn.setIconInvisible(interactable);
}
foreach (ButtonIcon btn in holder.auraSkills) {
btn.getButton().interactable = interactable;
btn.setIconInvisible(interactable);
}
foreach (ButtonIcon btn in holder.belt) {
btn.getButton().interactable = interactable;
btn.setIconInvisible(interactable);
}
}
void DropStuff()
{
//Drop Credits
int CoinDropAmount = Random.Range(minCoinDrop, maxCoinDrop + 1);
for (int i = 1; i <= CoinDropAmount; i++)
{
Instantiate(ObjectHolder._Credits[ObjectHolder.GetCreditValueIndex(ValueOfCreditDrop)], transform.position, Quaternion.Euler(0, 0, Random.Range(1, 360)));
}
//Drop PowerUp
if (PowerUpDropChangse != 0)
{
if (Random.Range(0f, 1f) <= PowerUpDropChangse)
{
Debug.Log("Drop PowerUp");
//PickUpBehaviourScript.PickUpTypes RandomPickUp = (PickUpBehaviourScript.PickUpTypes)Random.Range(1/*cus 0 is credit*/, ObjectHolder._PowerUps.Length - 1);
Instantiate(ObjectHolder._PowerUps[Random.Range(0, ObjectHolder._PowerUps.Length)], transform.position, Quaternion.identity);
}
}
}
void Start(){
foreach (GameObject searchable in GameObject.FindGameObjectsWithTag("Search")) { //creates list of searchable gameobjects
searchSpots.Add(searchable);
}
for (int i = 0; i < searchSpots.Count; i++) { //createes a list of items for mom and dad relative to searchable objects
DadRandom(Random.Range(0,6));
dadItems.Add(temp);
MomRandom(Random.Range(0,6));
momItems.Add(temp);
}
momItems[Random.Range(0,searchSpots.Count)] = "Rope"; //insert rope randomly into mom's list
for (int i = 0; i < searchSpots.Count; i++) { //assigns items out to searchable gameobjects
objectScript = searchSpots[i].GetComponent<ObjectHolder>();
objectScript.SetItems(momItems[i],dadItems[i]);
}
}
private void SetObject(IDataRecord data)
{
this.lastAccess = DateTime.Now;
int level = LocalStore.Level;
LocalStore.Level++;
for (int index = 0; index < this.entity.FieldCount; index++) {
FieldMap member = this.entity[index];
object nullValue = member.NullValue;
string fieldAlias = member.FieldAlias;
// Handle Database DateTimes not Supported by .NET from Nick Franceschina
object memberValue = null;
try {
memberValue = data[fieldAlias];
}
catch (ArgumentOutOfRangeException) {
memberValue = nullValue;
}
memberValue = this.MemberValue(memberValue, nullValue);
// Bug-Fix for Changes to Type by Jerry Shea (http://www.RenewTek.com)
this.values[index] = this.SetField(member, memberValue);
}
for (int index = 0; index < this.entity.RelationCount; index++) {
RelationMap relation = this.entity.Relation(index);
if (relation.QueryOnly) continue;
string typeName = relation.Type;
Type type = EntityMap.GetType(typeName);
Commands commands = this.context.Mappings.Commands(type);
string[] dataFields = new string[this.entity.KeyFields.Length];
for (int index0 = 0; index0 < this.entity.KeyFields.Length; index0++) {
dataFields[index0] = this.entity.KeyFields[index0].Field;
}
string[] relatedFields = relation.Fields;
object[] dataValues = new object[dataFields.Length];
for (int index1 = 0; index1 < dataFields.Length; index1++) {
dataValues[index1] = (data[dataFields[index1]] == DBNull.Value ? null : data[dataFields[index1]]);
}
string whereClause = relation.Filter;
string sortClause = this.context.Mappings[typeName].SortOrder;
ObjectQuery query = null;
SelectProcedure selectSP = null;
if (relation.SelectSP == null || relation.SelectSP.Length == 0) {
if (relation.Relationship == Relationship.Many) {
string manyTable = ((ManyMap)relation).Table;
string[] sourceFields = ((ManyMap)relation).Source;
string[] destFields = ((ManyMap)relation).Dest;
query = commands.ManyQuery(type, relatedFields, manyTable, sourceFields, destFields,
dataValues, whereClause, sortClause);
}
else if (relation.Relationship == Relationship.Child) {
query = commands.FieldQuery(type, relatedFields, dataValues, whereClause, sortClause);
}
}
else {
selectSP = new SelectProcedure(type, relation.SelectSP);
if (relation.Relationship == Relationship.Parent) {
for (int index2 = 0; index2 < relatedFields.Length; index2++) {
selectSP.AddParameter(relatedFields[index2], data[relatedFields[index2]]);
}
}
else {
for (int index3 = 0; index3 < relatedFields.Length; index3++) {
selectSP.AddParameter(relatedFields[index3], data[dataFields[index3]]);
}
}
}
object[] relatedValues = null;
if (relation.Relationship == Relationship.Parent && selectSP == null) {
relatedValues = new object[relatedFields.Length];
for (int index4 = 0; index4 < relatedFields.Length; index4++) {
relatedValues[index4] = (data[relatedFields[index4]] == DBNull.Value ? null : data[relatedFields[index4]]);
}
}
bool usedExisting = false;
object relations = null;
if (relation.Lazy) {
#if DOTNETV2
Type genericType = null;
object[] args = null;
if (relation.Relationship == Relationship.Parent) {
if (selectSP == null) {
if (relatedValues.Length == 1) {
genericType = typeof(ObjectHolder<>).MakeGenericType(type);
// Force proper ObjectHolder constructor to be called when relatedValues[0] is null - Steve Eichert (http:steve.emxsoftware.com)
args = new object[] { this.context, relatedValues[0] == null ? DBNull.Value : relatedValues[0] };
}
else {
genericType = typeof(ObjectHolder<>).MakeGenericType(type);
args = new object[] { this.context, relatedValues };
}
}
else {
genericType = typeof(ObjectHolder<>).MakeGenericType(type);
args = new object[] { this.context, selectSP };
}
}
else {
if (selectSP == null) {
genericType = typeof(ObjectList<>).MakeGenericType(type);
args = new object[] { this.context, query };
}
else {
genericType = typeof(ObjectList<>).MakeGenericType(type);
args = new object[] { this.context, selectSP };
}
}
relations = Activator.CreateInstance(genericType, internalFlags, null, args, null, null);
#else
if (relation.Relationship == Relationship.Parent) {
if (selectSP == null) {
if (relatedValues.Length == 1) {
relations = new ObjectHolder(this.context, type, relatedValues[0]);
}
else {
relations = new ObjectHolder(this.context, type, relatedValues);
}
}
else {
relations = new ObjectHolder(this.context, selectSP);
}
}
else {
if (selectSP == null) {
relations = new ObjectList(this.context, query);
}
else {
relations = new ObjectList(this.context, selectSP);
}
}
#endif
}
else {
// Avoid infinite relationship loop for non-lazy-loaded collections
if (LocalStore.IsLoaded(type) && level > 1)
continue;
if (relation.Relationship == Relationship.Parent) {
if (selectSP == null) {
if (relatedValues.Length == 1) {
relations = this.context.GetObject(type, relatedValues[0], false);
}
else {
relations = this.context.GetObject(type, relatedValues, false);
}
}
else {
relations = this.context.GetObjectSet(selectSP, false)[0];
}
}
else {
#if DOTNETV2
if (selectSP == null) {
using (ObjectReader reader = this.context.GetObjectReader(query, false)) {
Type genericType = typeof(ObjectSet<>).MakeGenericType(type);
object[] args = new object[] { reader };
relations = Activator.CreateInstance(genericType, internalFlags, null, args, null, null);
}
}
else {
using (ObjectReader reader = this.context.GetObjectReader(selectSP, false)) {
Type genericType = typeof(ObjectSet<>).MakeGenericType(type);
object[] args = new object[] { reader };
relations = Activator.CreateInstance(genericType, internalFlags, null, args, null, null);
}
}
#else
if (selectSP == null) {
relations = this.context.GetObjectSet(query, false);
}
else {
relations = this.context.GetObjectSet(selectSP, false);
}
#endif
// Do NOT initialize list relations for non-lazy entities with existing relations
IList relationList = this.GetField(relation.Member) as IList;
if (relationList != null) {
relationList.Clear();
foreach (object entity in relations as IEnumerable) {
relationList.Add(entity);
}
usedExisting = true;
}
}
}
if (!usedExisting) this.SetField(relation.Member, relations);
}
LocalStore.Level = level;
this.StartTracking(InitialState.Unchanged, false);
}
internal Instance(Context context, object entityObject, InitialState initialState)
: this(context, entityObject)
{
for (int index = 0; index < this.entity.RelationCount; index++) {
RelationMap relation = this.entity.Relation(index);
if (relation.QueryOnly) continue;
// Do NOT initialize relations for entities with existing relations
if (this.GetField(relation.Member) == null) {
string typeName = relation.Type;
Type type = EntityMap.GetType(typeName);
object relations = null;
if (!relation.Lazy && relation.Relationship == Relationship.Parent) {
relations = this.context.GetObject(type);
}
else {
#if DOTNETV2
Type genericType = null;
object[] args = null;
if (relation.Lazy) {
if (relation.Relationship == Relationship.Parent) {
genericType = typeof(ObjectHolder<>).MakeGenericType(type);
args = new object[] { this.context, DBNull.Value };
}
else {
genericType = typeof(ObjectList<>).MakeGenericType(type);
args = new object[] { this.context };
}
}
else {
genericType = typeof(ObjectSet<>).MakeGenericType(type);
args = new object[] { 1, 0, 0 };
}
relations = Activator.CreateInstance(genericType, internalFlags, null, args, null, null);
#else
if (relation.Lazy) {
if (relation.Relationship == Relationship.Parent) {
relations = new ObjectHolder(this.context, type, null);
}
else {
relations = new ObjectList(this.context, type);
}
}
else {
relations = new ObjectSet(type, 1, 0, 0);
}
#endif
}
this.SetField(relation.Member, relations);
}
}
this.StartTracking(initialState);
}
public static IEnumerator GetObjectAsync(BinaryNode currNode, ObjectHolder holder)
{
GameSerializer.< GetObjectAsync > c__Iterator38 <GetObjectAsync> c__Iterator = new GameSerializer.< GetObjectAsync > c__Iterator38();
public void Push(T Object)
{
ObjectHolder.Push(Object);
Object.GoInPool();
Factory.AfterSendToPool(Object);
}
public TerrainComponentManager(ScenarioModel scenario)
: base(scenario)
{
BspHolder = new ObjectHolder("sbsp");
SkyHolder = new ObjectHolder("sky");
}
protected void Awake()
{
item = this.GetComponent <Item>();
module = item.data.GetModule <ItemModuleFetch>();
holder = item.GetComponentInChildren <ObjectHolder>();
holder.UnSnapped += new ObjectHolder.HolderDelegate(this.OnWeaponItemRemoved);
//Trim list of ItemPhysic IDs by sub-type. Each ItemPhysic has its own type, defined by these enum indicies:
//Misc = 0
//Weapon = 1
//Quiver = 2
//Potion = 3
//Prop = 4
//Body = 5
//Shield = 6
//Get all ItemPhysic IDs from the chosen category. If no valid itemCategory is set, then no trimming is done and all types are valid for return
if (module.itemCategory >= 0 || module.itemCategory > 6)
{
var categoryEnums = Enum.GetValues(typeof(ItemPhysic.Type));
ItemPhysic.Type chosenCategory = (ItemPhysic.Type)categoryEnums.GetValue(module.itemCategory);
itemsList = Catalog.GetAllID <ItemPhysic>().FindAll(i => Catalog.GetData <ItemPhysic>(i, true).type.Equals(chosenCategory));
//Only include ItemPhysic IDs which are purchasable
itemsList = itemsList.FindAll(i => Catalog.GetData <ItemPhysic>(i, true).purchasable.Equals(true));
}
//Otherwise, populate the list with everything as long as it is purchasable
else
{
itemsList = Catalog.GetAllID <ItemPhysic>().FindAll(i => Catalog.GetData <ItemPhysic>(i, true).purchasable.Equals(true));
}
// If the plugin is in `overrideMode`, first fetch items from the given category (if supplied) and then add any additionally given items to the parsed list
if (module.overrideMode)
{
parsedItemsList = new List <string>();
if (!String.IsNullOrEmpty(module.overrideCategory))
{
parsedItemsList = itemsList.FindAll(i => Catalog.GetData <ItemPhysic>(i, true).categoryPath.Any(j => j.Contains(module.overrideCategory)));
}
foreach (string itemName in module.overrideItems)
{
if (!parsedItemsList.Contains(itemName) && itemsList.Contains(itemName))
{
parsedItemsList.Add(itemName);
}
}
}
// Otherwise if not in override mode, then load all items from all categories (from the given BS master list), optionally exluding specific categories and items
else
{
parsedItemsList = new List <string>(itemsList);
foreach (string categoryName in module.excludedCategories)
{
parsedItemsList = parsedItemsList.FindAll(i => !Catalog.GetData <ItemPhysic>(i, true).categoryPath.Any(j => j.Contains(categoryName)));
}
foreach (string itemName in module.excludedItems)
{
parsedItemsList = parsedItemsList.FindAll(i => !i.Contains(itemName));
}
}
// If no capacity is defined, default to infinite usages. Otherwise, set up a tracker for remaining uses
if (module.capacity <= 0)
{
infiniteUses = true;
}
else
{
usesRemaining = module.capacity - 1;
}
// Spawn initial random item in the holder
SpawnAndSnap(GetRandomItemID(parsedItemsList), holder);
return;
}
// fsm interface
public void AttachExitEffect(ObjectHolder target)
{
GameObject child = RecycleManager.Instance.Instantiate("vfx08002_Advent_Retreat01");
target.AttachChild(child, "BC", new Vector3(0, 0, 0.5f));
}
void OnTriggerExit2D(Collider2D other){
objectPresent = false;
thisObject = null;
objectScript = null;
}
public DestructionManager(ObjectHolder holder)
{
_objHold = holder;
}
public GameLogics(ObjectHolder holder)
{
_objHolder = holder;
}
public CollisionManager(ObjectHolder holder)
{
_objHold = holder;
}
private static IEnumerator LoadAsync(BinaryDomDocument document, ObjectHolder holder)
{
GameSerializer.< LoadAsync > c__Iterator5 <LoadAsync> c__Iterator = new GameSerializer.< LoadAsync > c__Iterator5();
private void Awake()
{
instance = this;
}
protected override void LoadContent()
{
//Initialize the GameInfo:
GameInfo.RefSpriteBatch = spriteBatch;
GameInfo.RefDevice = Device;
GameInfo.RefDeviceManager = graphics;
GameInfo.RefContent = Content;
//Initialize some more static classes:
TextureHolder.Initialize();
SoundHolder.Initialize();
MouseManager.Initialize();
//Initalize the grid:
Grid grid = new Grid(new Vector2(0, 0), 100, 40);
Grid gridFloor = new Grid(new Vector2(0, 0), 100, 40);
ObjectHolder.Create(grid);
ObjectHolder.Create(gridFloor);
//Initialize the camera:
Camera.Initialize(new Vector2(0, 0));
//Initialize default sprites:
TextureHolder.DefaultTextures[typeof(DungeonWall)] = TextureHolder.AddTexture("DungeonWall");
TextureHolder.DefaultTextures[typeof(DungeonFloor)] = TextureHolder.AddTexture("DungeonFloor");
TextureHolder.DefaultTextures[typeof(DungeonFloor2)] = TextureHolder.AddTexture("DungeonFloor2");
TextureHolder.DefaultTextures[typeof(Player)] = TextureHolder.AddTexture("Player");
TextureHolder.DefaultTextures[typeof(PlayerLegs)] = TextureHolder.AddTexture("PlayerLegs");
TextureHolder.DefaultTextures[typeof(PlayerSword)] = TextureHolder.AddTexture("PlayerSword");
TextureHolder.DefaultTextures[typeof(CannonBot)] = TextureHolder.AddTexture("CannonBot");
TextureHolder.DefaultTextures[typeof(Sink)] = TextureHolder.AddTexture("Sink");
//Load sounds:
//Create game objects:
gridFloor.CreateFromString( //Make the floor
new Dictionary <char, Type>()
{
{ 'f', typeof(DungeonFloor) },
{ 's', typeof(DungeonFloor2) },
{ '.', null }
},
new Dictionary <char, GameObject>()
{
},
new string[] {
"..............",
".sfffffffffff.",
".ffffffffffff.",
".ffffffffffff..........",
".fffffffffffffffsfffff.",
".fffffffsfffffffffffff.",
".fffffffffffffffffffff.",
".fffffffffffffffffffff.",
".ffffffffffff..........",
".fffsffffffff.",
".ffffffffffff.",
".............."
});
grid.CreateFromString(
new Dictionary <char, Type>()
{
{ 'w', typeof(DungeonWall) },
{ 'p', typeof(Player) },
{ 'c', typeof(CannonBot) },
{ 's', typeof(Sink) },
{ '.', null }
},
new Dictionary <char, GameObject>()
{
{ '1', new Sink(new Vector2(0, 0), MazeGameEngine.FurnitureDirection.Up) }
},
new string[] {
"wwwwwwwwwwwwww",
"w............w",
"w............w",
"w............wwwwwwwwww",
"w.....................w",
"w.....p...............w",
"w.....................w",
"w.....................w",
"w............wwwwwwwwww",
"w............w",
"w.....1......w",
"wwwwwwwwwwwwww"
});
//Make a reference to the UI objects: (so that other objects can interact with them)
}
public void LoadScenario(int scenarioNo)
{
sceneListView.RootLists.Clear();
cameraListView.RootLists.Clear();
lightsSceneListView.RootLists.Clear();
scene.objects.Clear();
cameraScene.objects.Clear();
lightScene.objects.Clear();
layerViewerDropDown.DropDownItems.Clear();
// we want to clear out the children of the 5 camera type root nodes
//for (int i = 0; i < 5; i++)
// camerasTree.Nodes[i].Nodes.Clear();
mGalaxy.SetScenario(scenarioNo);
scenarioNameTxtBox.Text = mGalaxy.mCurScenarioName;
// first we need to get the proper layers that the galaxy itself uses
List <string> layers = mGalaxy.GetGalaxyLayers(mGalaxy.GetMaskUsedInZoneOnCurrentScenario(mGalaxyName));
layers.ForEach(l => layerViewerDropDown.DropDownItems.Add(l));
// get our main galaxy's zone
Zone mainZone = mGalaxy.GetZone(mGalaxyName);
// now we get the zones used on these layers
List <string> zonesUsed = new List <string>
{
// add our galaxy name itself so we can properly add it to a scene list with the other zones
mGalaxyName
};
zonesUsed.AddRange(mainZone.GetZonesUsedOnLayers(layers));
Dictionary <string, int> zoneMasks = new Dictionary <string, int>();
ObjectHolder mainHolder = new ObjectHolder();
Dictionary <string, List <Camera> > cameras = new Dictionary <string, List <Camera> >();
List <Light> lights = new List <Light>();
List <PathPointObj> pathpoints = new List <PathPointObj>();
foreach (string zone in zonesUsed)
{
zoneMasks.Add(zone, mGalaxy.GetMaskUsedInZoneOnCurrentScenario(zone));
Zone z = mGalaxy.GetZone(zone);
ObjectHolder curHolder = z.GetAllObjectsFromLayers(mGalaxy.GetGalaxyLayers(zoneMasks[zone]));
foreach (PathObj pobj in z.mPaths)
{
pathpoints.AddRange(pobj.mPathPointObjs);
}
cameras.Add(zone, z.mCameras);
if (z.mLights != null)
{
lights.AddRange(z.mLights);
}
if (!z.mIsMainGalaxy)
{
Zone galaxyZone = mGalaxy.GetGalaxyZone();
// the first step
List <string> galaxyLayers = mGalaxy.GetGalaxyLayers(zoneMasks[mGalaxy.mName]);
foreach (string layer in galaxyLayers)
{
List <StageObj> stages = galaxyZone.mZones[layer];
foreach (StageObj o in stages)
{
if (o.mName == z.mZoneName)
{
curHolder.ApplyZoneOffset(o.mPosition, o.mRotation);
}
}
}
}
mainHolder.AddObjects(curHolder);
}
sceneListView.RootLists.Add("Areas", mainHolder.GetObjectsOfType("AreaObj"));
sceneListView.RootLists.Add("Camera Areas", mainHolder.GetObjectsOfType("CameraObj"));
sceneListView.RootLists.Add("Objects", mainHolder.GetObjectsOfType("Obj"));
sceneListView.RootLists.Add("Demos", mainHolder.GetObjectsOfType("DemoObj"));
sceneListView.RootLists.Add("Positions", mainHolder.GetObjectsOfType("GeneralPosObj"));
sceneListView.RootLists.Add("Debug", mainHolder.GetObjectsOfType("DebugMoveObj"));
sceneListView.RootLists.Add("Gravity", mainHolder.GetObjectsOfType("PlanetObj"));
sceneListView.RootLists.Add("Start", mainHolder.GetObjectsOfType("StartObj"));
sceneListView.RootLists.Add("Map Parts", mainHolder.GetObjectsOfType("MapPartsObj"));
sceneListView.RootLists.Add("Paths", pathpoints);
sceneListView.UpdateComboBoxItems();
sceneListView.SelectedItems = scene.SelectedObjects;
sceneListView.SetRootList("Areas");
scene.objects.AddRange(mainHolder.GetObjectsOfType("AreaObj"));
scene.objects.AddRange(mainHolder.GetObjectsOfType("CameraObj"));
scene.objects.AddRange(mainHolder.GetObjectsOfType("Obj"));
scene.objects.AddRange(mainHolder.GetObjectsOfType("DemoObj"));
scene.objects.AddRange(mainHolder.GetObjectsOfType("GeneralPosObj"));
scene.objects.AddRange(mainHolder.GetObjectsOfType("DebugMoveObj"));
scene.objects.AddRange(mainHolder.GetObjectsOfType("PlanetObj"));
scene.objects.AddRange(mainHolder.GetObjectsOfType("StartObj"));
scene.objects.AddRange(mainHolder.GetObjectsOfType("MapPartsObj"));
scene.objects.AddRange(pathpoints);
List <Camera> cubeCameras = new List <Camera>();
List <Camera> groupCameras = new List <Camera>();
List <Camera> eventCameras = new List <Camera>();
List <Camera> startCameras = new List <Camera>();
List <Camera> otherCameras = new List <Camera>();
foreach (string zone in zonesUsed)
{
cameras[zone].ForEach(c =>
{
if (c.GetCameraType() == Camera.CameraType.Cube)
{
cubeCameras.Add(c);
}
});
cameras[zone].ForEach(c =>
{
if (c.GetCameraType() == Camera.CameraType.Group)
{
groupCameras.Add(c);
}
});
cameras[zone].ForEach(c =>
{
if (c.GetCameraType() == Camera.CameraType.Event)
{
eventCameras.Add(c);
}
});
cameras[zone].ForEach(c =>
{
if (c.GetCameraType() == Camera.CameraType.Start)
{
startCameras.Add(c);
}
});
cameras[zone].ForEach(c =>
{
if (c.GetCameraType() == Camera.CameraType.Other)
{
otherCameras.Add(c);
}
});
}
cameraListView.RootLists.Add("Cube", cubeCameras);
cameraListView.RootLists.Add("Group", groupCameras);
cameraListView.RootLists.Add("Event", eventCameras);
cameraListView.RootLists.Add("Start", startCameras);
cameraListView.RootLists.Add("Other", otherCameras);
cameraListView.UpdateComboBoxItems();
cameraListView.SelectedItems = cameraScene.SelectedObjects;
cameraListView.SetRootList("Cube");
cameraScene.objects.AddRange(cubeCameras);
cameraScene.objects.AddRange(groupCameras);
cameraScene.objects.AddRange(eventCameras);
cameraScene.objects.AddRange(startCameras);
cameraScene.objects.AddRange(otherCameras);
lightsSceneListView.RootLists.Add("Lights", lights);
lightsSceneListView.UpdateComboBoxItems();
lightsSceneListView.SelectedItems = lightScene.SelectedObjects;
lightsSceneListView.SetRootList("Lights");
lightScene.objects.AddRange(lights);
galaxyViewControl.Refresh();
}
public InitialSceneSpawner(ObjectHolder holder, CollisionManager collMan)
{
_objectPrefabs = new Dictionary <string, UnityEngine.Object>();
_objHolder = holder;
_collMan = collMan;
}
void FireWeapon()
{
switch (currentWeapon)
{
case (Weapons.Standart_lvl_1):
if (Input.GetButton("Fire1"))
{
cooldown = 0.3f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.BlasterShoot_lvl_1)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.Standart_lvl_2):
if (Input.GetButton("Fire1"))
{
cooldown = 0.3f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.BlasterShoot_lvl_1)], ProjectileSpawnPoint + (TurretGameObject.transform.right * 0.1f), TurretGameObject.transform.rotation);
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.BlasterShoot_lvl_1)], ProjectileSpawnPoint + (TurretGameObject.transform.right * -0.1f), TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.Standart_lvl_3):
if (Input.GetButton("Fire1"))
{
cooldown = 0.4f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.BlasterShoot_lvl_1)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.BlasterShoot_lvl_1)], ProjectileSpawnPoint + (TurretGameObject.transform.right * 0.2f), TurretGameObject.transform.rotation);
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.BlasterShoot_lvl_1)], ProjectileSpawnPoint + (TurretGameObject.transform.right * -0.2f), TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.Helix_lvl_1):
if (Input.GetButton("Fire1"))
{
cooldown = 0.5f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.HelixBullet_lvl_1)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.Helix_lvl_2):
if (Input.GetButton("Fire1"))
{
cooldown = 0.7f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.HelixBullet_lvl_2)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.Helix_lvl_3):
if (Input.GetButton("Fire1"))
{
cooldown = 0.9f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.HelixBullet_lvl_3)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.Spread):
if (Input.GetButton("Fire1"))
{
cooldown = 0.4f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.BlasterShoot_lvl_1)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.BlasterShoot_lvl_1)], ProjectileSpawnPoint, TurretGameObject.transform.rotation * Quaternion.Euler(0, 0, -10));
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.BlasterShoot_lvl_1)], ProjectileSpawnPoint, TurretGameObject.transform.rotation * Quaternion.Euler(0, 0, 10));
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.Homing_lvl_1):
if (Input.GetButton("Fire1"))
{
cooldown = 0.3f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
float BulletRng = 1f;
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.HomingBullet_lvl_1)], ProjectileSpawnPoint, TurretGameObject.transform.rotation * Quaternion.Euler(0, 0, Random.Range(BulletRng, -BulletRng)));
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.Homing_lvl_2):
if (Input.GetButton("Fire1"))
{
cooldown = 0.2f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
float BulletRng = 6f;
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.HomingBullet_lvl_2)], ProjectileSpawnPoint, TurretGameObject.transform.rotation * Quaternion.Euler(0, 0, Random.Range(BulletRng, -BulletRng)));
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.Homing_lvl_3):
if (Input.GetButton("Fire1"))
{
cooldown = 0.1f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
float BulletRng = 12f;
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.HomingBullet_lvl_3)], ProjectileSpawnPoint, TurretGameObject.transform.rotation * Quaternion.Euler(0, 0, Random.Range(BulletRng, -BulletRng)));
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.LaserSword_lvl_1):
if (Input.GetButton("Fire1"))
{
cooldown = 0.5f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
float fieldSize = 1.25f;
Vector3 RndFieldPos = transform.position + (TurretGameObject.transform.right * Random.Range(-fieldSize, fieldSize)) + (TurretGameObject.transform.up * Random.Range(-fieldSize, -fieldSize / 2)); //new Vector3(Random.Range(-fieldSize, fieldSize), ;
Quaternion LookToMouse = Quaternion.LookRotation(Vector3.forward, (new Vector3(Camera.main.ScreenToWorldPoint(Input.mousePosition).x, Camera.main.ScreenToWorldPoint(Input.mousePosition).y, 0) - RndFieldPos));
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.LaserSword_lvl_1)], RndFieldPos, LookToMouse);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.WaveEmitter_lvl_1):
if (Input.GetButton("Fire1"))
{
cooldown = 0.3f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.WaveBullet_lvl_X)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.RocketLauncher_lvl_1):
if (Input.GetButton("Fire1"))
{
cooldown = 0.8f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.Missile_lvl_1)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.GrenadeLauncher_lvl_1):
if (Input.GetButton("Fire1"))
{
cooldown = 0.8f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.Grenade_lvl_1)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.ShrapnelLauncher_lvl_1):
if (Input.GetButton("Fire1"))
{
cooldown = 0.8f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.Shrapnel_lvl_1)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.ShrapnelLauncher_lvl_2):
if (Input.GetButton("Fire1"))
{
cooldown = 1.2f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.Shrapnel_lvl_2)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.ShrapnelLauncher_lvl_3):
if (Input.GetButton("Fire1"))
{
cooldown = 1.4f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
Instantiate(Bullets[ObjectHolder.GetBulletIndex(ProjectileBehaviourScript.BulletTypes.Shrapnel_lvl_3)], ProjectileSpawnPoint, TurretGameObject.transform.rotation);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.ChainGun_lvl_1):
if (Input.GetButton("Fire1"))
{
cooldown = 0.01f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
fireChainGun(0.04f, 0.1f, 6f);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.ChainGun_lvl_2):
if (Input.GetButton("Fire1"))
{
cooldown = 0.01f * fireRateMultiplyer * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
fireChainGun(0.04f, 0.1f, 3f);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.ChainGun_lvl_3):
if (Input.GetButton("Fire1"))
{
cooldown = 0.005f * fireRateMultiplyer;
if (cooldownTimeStamp <= Time.time)
{
fireChainGun(0.04f, 0.1f, 1f);
cooldownTimeStamp = Time.time + cooldown;
}
}
break;
case (Weapons.LaserGun):
cooldown = 2f * fireRateMultiplyer;
loadTime = 1f;
if (cooldownTimeStamp <= Time.time)
{
if (Input.GetButtonDown("Fire1"))
{
pressedButtonDown = true;
loadTimeStamp = Time.time + loadTime;
isReady = true;
}
if (loadTimeStamp >= Time.time)
{
if (isReady == true)
{
Debug.Log("Loading");
}
}
if (loadTimeStamp <= Time.time)
{
if (isReady == true)
{
Instantiate(ObjectHolder._Effects[ObjectHolder.GetEffectIndex(EffectBehaviourScript.EffectTypes.LaserLoaded)], transform.position, transform.rotation, transform);
isReady = false;
}
}
}
break;
default:
Debug.LogError("The Weapon Type -" + currentWeapon.ToString() + "- has no values assinged!");
break;
}
}
public void Spotlight(ObjectHolder target)
{
Assert.IsTrue(spTarget == null);
spTarget = target;
int newLayer = LayerMask.NameToLayer("Spotlight");
spTarget.CullingLayer = newLayer;
rawCamera.cullingMask = 1 << newLayer;
}
private void OnDestroy()
{
instance = null;
instantiated--;
}
public void CancelSpotlight()
{
Assert.IsTrue(spTarget != null);
int originLayer = rawCamera.gameObject.layer;
spTarget.CullingLayer = originLayer;
rawCamera.cullingMask = 1 << originLayer;
spTarget = null;
}
public Player(Vector2 position)
: base(position)
{
_legs = new PlayerLegs(this);
ObjectHolder.Create(_legs);
}
public BuffControl(ObjectHolder owner, Stat stat)
{
this.owner = owner;
this.stat = stat;
}
public Player()
: base()
{
_legs = new PlayerLegs(this);
ObjectHolder.Create(_legs);
}
protected void Awake()
{
item = this.GetComponent <Item>();
module = item.data.GetModule <ItemModuleShooter>();
isShootingAllowed = true;
bulletSpawn = item.transform.Find(module.bulletSpawnName);
if (module.shootSFX != "None")
{
if (item.transform.Find(module.shootSFX))
{
if (item.transform.Find(module.shootSFX).gameObject.GetComponentInChildren <AudioSource>())
{
shotSFX = item.transform.Find(module.shootSFX).gameObject.GetComponentInChildren <AudioSource>();
}
else
{
Debug.LogError("ItemShooter error: ShootSFX gameObject doesn't contain an Audio Source");
}
}
else
{
Debug.LogError("ItemShooter error: ShootSFX gameObject couldn't be found");
}
}
if (module.triggerPressSFX != "None")
{
if (item.transform.Find(module.triggerPressSFX))
{
if (item.transform.Find(module.triggerPressSFX).gameObject.GetComponentInChildren <AudioSource>())
{
triggerPressedSFX = item.transform.Find(module.triggerPressSFX).gameObject.GetComponentInChildren <AudioSource>();
}
else
{
Debug.LogError("ItemShooter error: triggerPressSFX gameObject doesn't contain an Audio Source");
}
}
else
{
Debug.LogError("ItemShooter error: triggerPressSFX gameObject couldn't be found");
}
}
if (module.shootVFX != "None")
{
if (item.transform.Find(module.shootVFX))
{
if (item.transform.Find(module.shootVFX).gameObject.GetComponentInChildren <ParticleSystem>())
{
shotVFX = item.transform.Find(module.shootVFX).gameObject.GetComponentInChildren <ParticleSystem>();
}
else
{
Debug.LogError("ItemShooter error: shootVFX gameObject doesn't contain a Particle System");
}
}
else
{
Debug.LogError("ItemShooter error: shootVFX gameObject couldn't be found");
}
}
if (module.triggerPressVFX != "None")
{
if (item.transform.Find(module.triggerPressVFX))
{
if (item.transform.Find(module.triggerPressVFX).gameObject.GetComponentInChildren <ParticleSystem>())
{
triggerPressedVFX = item.transform.Find(module.triggerPressVFX).gameObject.GetComponentInChildren <ParticleSystem>();
}
else
{
Debug.LogError("ItemShooter error: triggerPressVFX gameObject doesn't contain a Particle System");
}
}
else
{
Debug.LogError("ItemShooter error: triggerPressVFX gameObject couldn't be found");
}
}
if (item.GetComponentInChildren <ObjectHolder>())
{
gunHolder = item.GetComponentInChildren <ObjectHolder>();
}
if (item.GetComponentInChildren <Animation>())
{
animation = item.GetComponentInChildren <Animation>();
}
item.OnHeldActionEvent += OnTriggerPressed;
item.OnUngrabEvent += OnGunUngrab;
projectileOriginal = Catalog.current.GetData <ItemData>(module.projectileID, true);
}
