public bool chosen; //so the priority is chosen only once;
// Use this for initialization
public override void Start()
{
base.Start(); //run the PlayerController start function
cpuRigidBody = GetComponent <Rigidbody2D> ();
cpuCollider2d = GetComponent <BoxCollider2D> ();
timeBetweenMoveCounter = timeBetweenMove;
timeToMoveCounter = timeToMove;
_gameMap = GameObject.Find("MapController").GetComponent <MapController> ()._gameMap;
moveFinished = true;
playerMoving = false;
moveToPosition = Vector3.zero;
position1 = transform.position;
movingLeft = false;
movingRight = false;
movingUp = false;
movingDown = false;
//teamBaseReference = PeekAtBase ();
//teamBaseInventoryReference = teamBaseReference.GetComponent<BaseController>().baseInventory;
allPossibleItems = GameObject.FindWithTag("All Game Items").GetComponent <GameItems>();
elementNames = allPossibleItems.allGameItems.GetListOfElementNames();
priorityChoice = rand.Next(_aiPriorities.Length);
chosen = true;
CPUPlayer = true;
//start the AI player on one of the not occupied bases, handled in the BaseController
}
private void SaveGaveItemClick(object sender, RoutedEventArgs e)
{
//Validate data
string message;
if (!IsValidate(out message))
{
RaiseInformMessage(message);
return;
}
// Add new or update
switch (_currentAction)
{
case ActionState.Add:
GameItems.Add(NewGameItem);
FileManagement.SaveListGameData(GameItems);
RaiseInformMessage("Data has been added successfully");
break;
case ActionState.Update:
UpdateProperty(SelectedGameItem, UpdateGameItem);
FileManagement.SaveListGameData(GameItems);
RaiseInformMessage("Data has been saved successfully");
break;
}
//Re-load data
LoadData();
}
public override void InitPhase()
{
inventoryRepository = GameState.Instance.Inventory;
gameItems = new GameItems();
AddItemToInventory();
base.InitPhase();
}
public static void AddItem(string name, GameItem item)
{
if (!GameItems.ContainsKey(name))
{
GameItems.Add(name, item);
}
}
public static void SP_trigger_key(edict_t self)
{
if (GameBase.st.item == null)
{
GameBase.gi.Dprintf("no key item for trigger_key at " + Lib.Vtos(self.s.origin) + "\\n");
return;
}
self.item = GameItems.FindItemByClassname(GameBase.st.item);
if (null == self.item)
{
GameBase.gi.Dprintf("item " + GameBase.st.item + " not found for trigger_key at " + Lib.Vtos(self.s.origin) + "\\n");
return;
}
if (self.target == null)
{
GameBase.gi.Dprintf(self.classname + " at " + Lib.Vtos(self.s.origin) + " has no target\\n");
return;
}
GameBase.gi.Soundindex("misc/keytry.wav");
GameBase.gi.Soundindex("misc/keyuse.wav");
self.use = trigger_key_use;
}
public void showItem()
{
gi = GameObject.Find("GameItems(Clone)").GetComponent <GameItems>();
costumeName = costumeName.Substring(1, costumeName.Length - 2);
costumeNameText.text = costumeName + "(" + quantity + ")";
costumeImage.GetComponent <Image>().sprite = Resources.Load <Sprite>("Costume Icon/" + costumeName);
}
public IActionResult Update([FromBasicAuth] string auth, [FromBody] ScoreItem item, string id)
{
if (item == null)
{
return(BadRequest());
}
var score = ScoreItems.Find(id);
if (score == null)
{
return(NotFound());
}
if (!Auth.IsAllowed(auth, score.Game, UserPermission.UpdateScores))
{
return(Auth.Result);
}
item.Key = score.Key;
if (GameItems.Find(item.Game) == null)
{
return(BadRequest("Game not found"));
}
ScoreItems.Update(item);
return(new NoContentResult());
}
public void showItem()
{
gi = GameObject.Find("GameItems(Clone)").GetComponent <GameItems>();
weaponName = weaponName.Substring(1, weaponName.Length - 2);
weaponNameText.text = weaponName + "(" + quantity + ")";
weaponImage.GetComponent <Image>().sprite = Resources.Load <Sprite>("Weapon Icon/" + weaponName);
}
public static void Use_f(edict_t ent)
{
Int32 index;
gitem_t it;
String s;
s = Cmd.Args();
it = GameItems.FindItem(s);
Com.Dprintln("using:" + s);
if (it == null)
{
SV_GAME.PF_cprintfhigh(ent, "unknown item: " + s + "\\n");
return;
}
if (it.use == null)
{
SV_GAME.PF_cprintfhigh(ent, "Item is not usable.\\n");
return;
}
index = GameItems.ITEM_INDEX(it);
if (0 == ent.client.pers.inventory[index])
{
SV_GAME.PF_cprintfhigh(ent, "Out of item: " + s + "\\n");
return;
}
it.use.Use(ent, it);
}
public static void Drop_f(edict_t ent)
{
Int32 index;
gitem_t it;
String s;
s = Cmd.Args();
it = GameItems.FindItem(s);
if (it == null)
{
SV_GAME.PF_cprintfhigh(ent, "unknown item: " + s + "\\n");
return;
}
if (it.drop == null)
{
SV_GAME.PF_cprintf(ent, Defines.PRINT_HIGH, "Item is not dropable.\\n");
return;
}
index = GameItems.ITEM_INDEX(it);
if (0 == ent.client.pers.inventory[index])
{
SV_GAME.PF_cprintfhigh(ent, "Out of item: " + s + "\\n");
return;
}
it.drop.Drop(ent, it);
}
public static void WeapLast_f(edict_t ent)
{
gclient_t cl;
Int32 index;
gitem_t it;
cl = ent.client;
if (null == cl.pers.weapon || null == cl.pers.lastweapon)
{
return;
}
index = GameItems.ITEM_INDEX(cl.pers.lastweapon);
if (0 == cl.pers.inventory[index])
{
return;
}
it = GameItemList.itemlist[index];
if (null == it.use)
{
return;
}
if (0 == (it.flags & Defines.IT_WEAPON))
{
return;
}
it.use.Use(ent, it);
}
private void ImportListAndAddClick(object sender, RoutedEventArgs e)
{
var dialog = new OpenFileDialog
{
Filter = "All file|*.*|JPEG file (.jpg)|*.jpg|PNG file (.png)|*.png|Bitmap file (.bmp)|*.bmp",
Multiselect = true
};
if (dialog.ShowDialog() != true)
{
return;
}
bool addQuestionMark = NewGameItem.GameName == Constant.GameConstant.TalkInMinute;
foreach (var fileName in dialog.FileNames)
{
//NewGameItem
GameItems.Add(new GameItem
{
GameName = NewGameItem.GameName,
Topic = NewGameItem.Topic,
Title = Path.GetFileNameWithoutExtension(fileName) + (addQuestionMark ? "?" : string.Empty),
Image = ConvertHelper.ImageToByte(fileName)
});
}
FileManagement.SaveListGameData(GameItems);
RaiseInformMessage("Data has been imported successfully");
//Re-load data
NewGameItem.Title = Path.GetFileNameWithoutExtension(dialog.FileNames[0]) + (addQuestionMark ? "?" : string.Empty);
LoadData();
}
public static void InitGame( )
{
GameBase.gi.Dprintf("==== InitGame ====\\n");
// TODO - Do we need this? Everything is static
//for (int n = 0; n < preloadclasslist.Length; n++)
//{
// try
// {
// Class.ForName(preloadclasslist[n]);
// }
// catch (Exception e)
// {
// Com.DPrintf("error loading class: " + e.GetMessage());
// }
//}
GameBase.gun_x = GameBase.gi.Cvar_f("gun_x", "0", 0);
GameBase.gun_y = GameBase.gi.Cvar_f("gun_y", "0", 0);
GameBase.gun_z = GameBase.gi.Cvar_f("gun_z", "0", 0);
GameBase.sv_rollspeed = GameBase.gi.Cvar_f("sv_rollspeed", "200", 0);
GameBase.sv_rollangle = GameBase.gi.Cvar_f("sv_rollangle", "2", 0);
GameBase.sv_maxvelocity = GameBase.gi.Cvar_f("sv_maxvelocity", "2000", 0);
GameBase.sv_gravity = GameBase.gi.Cvar_f("sv_gravity", "800", 0);
Globals.dedicated = GameBase.gi.Cvar_f("dedicated", "0", Defines.CVAR_NOSET);
GameBase.sv_cheats = GameBase.gi.Cvar_f("cheats", "0", Defines.CVAR_SERVERINFO | Defines.CVAR_LATCH);
GameBase.gi.Cvar_f("gamename", Defines.GAMEVERSION, Defines.CVAR_SERVERINFO | Defines.CVAR_LATCH);
GameBase.gi.Cvar_f("gamedate", Globals.__DATE__, Defines.CVAR_SERVERINFO | Defines.CVAR_LATCH);
GameBase.maxclients = GameBase.gi.Cvar_f("maxclients", "4", Defines.CVAR_SERVERINFO | Defines.CVAR_LATCH);
GameBase.maxspectators = GameBase.gi.Cvar_f("maxspectators", "4", Defines.CVAR_SERVERINFO);
GameBase.deathmatch = GameBase.gi.Cvar_f("deathmatch", "0", Defines.CVAR_LATCH);
GameBase.coop = GameBase.gi.Cvar_f("coop", "0", Defines.CVAR_LATCH);
GameBase.skill = GameBase.gi.Cvar_f("skill", "0", Defines.CVAR_LATCH);
GameBase.maxentities = GameBase.gi.Cvar_f("maxentities", "1024", Defines.CVAR_LATCH);
GameBase.dmflags = GameBase.gi.Cvar_f("dmflags", "0", Defines.CVAR_SERVERINFO);
GameBase.fraglimit = GameBase.gi.Cvar_f("fraglimit", "0", Defines.CVAR_SERVERINFO);
GameBase.timelimit = GameBase.gi.Cvar_f("timelimit", "0", Defines.CVAR_SERVERINFO);
GameBase.password = GameBase.gi.Cvar_f("password", "", Defines.CVAR_USERINFO);
GameBase.spectator_password = GameBase.gi.Cvar_f("spectator_password", "", Defines.CVAR_USERINFO);
GameBase.needpass = GameBase.gi.Cvar_f("needpass", "0", Defines.CVAR_SERVERINFO);
GameBase.filterban = GameBase.gi.Cvar_f("filterban", "1", 0);
GameBase.g_select_empty = GameBase.gi.Cvar_f("g_select_empty", "0", Defines.CVAR_ARCHIVE);
GameBase.run_pitch = GameBase.gi.Cvar_f("run_pitch", "0.002", 0);
GameBase.run_roll = GameBase.gi.Cvar_f("run_roll", "0.005", 0);
GameBase.bob_up = GameBase.gi.Cvar_f("bob_up", "0.005", 0);
GameBase.bob_pitch = GameBase.gi.Cvar_f("bob_pitch", "0.002", 0);
GameBase.bob_roll = GameBase.gi.Cvar_f("bob_roll", "0.002", 0);
GameBase.flood_msgs = GameBase.gi.Cvar_f("flood_msgs", "4", 0);
GameBase.flood_persecond = GameBase.gi.Cvar_f("flood_persecond", "4", 0);
GameBase.flood_waitdelay = GameBase.gi.Cvar_f("flood_waitdelay", "10", 0);
GameBase.sv_maplist = GameBase.gi.Cvar_f("sv_maplist", "", 0);
GameItems.InitItems();
GameBase.game.helpmessage1 = "";
GameBase.game.helpmessage2 = "";
GameBase.game.maxentities = ( Int32 )GameBase.maxentities.value;
CreateEdicts();
GameBase.game.maxclients = ( Int32 )GameBase.maxclients.value;
CreateClients();
GameBase.num_edicts = GameBase.game.maxclients + 1;
}
public static GameItem GetItem(string name)
{
if (GameItems.ContainsKey(name))
{
return((GameItem)GameItems[name].Clone());
}
return(null);
}
public static GameObject GetSprite(GameItems id)
{
if (progress.sprites.ContainsKey(id))
{
return(progress.sprites[id]);
}
return(progress.defaultSprite);
}
public void AddGameItem(GameItem newItem)
{
if (newItem != null)
{
lock (lockObj)
{
GameItems.Add(newItem.ItemId, newItem);
}
}
}
public static void ValidateSelectedItem(edict_t ent)
{
gclient_t cl = ent.client;
if (cl.pers.inventory[cl.pers.selected_item] != 0)
{
return;
}
GameItems.SelectNextItem(ent, -1);
}
public void Shoot(string nick, int itemId, int otherId, int numUnits)
{
lock (lockObj)
{
GameItem akt = GetItem(nick, itemId);
if (akt != null && GameItems.ContainsKey(otherId))
{
RealShoot(GameItems[itemId], GameItems[otherId], numUnits);
}
}
}
private void OnClick_Sell(object sender, RoutedEventArgs e)
{
GameItems item = ((FrameworkElement)sender).DataContext as GameItems;
if (item != null)
{
Session.CurrentPlayer.Gold += item.Price;
Session.CurrentTrader.AddItemToInventory(item);
Session.CurrentPlayer.RemoveItemFromInventory(item);
}
}
public App()
{
InitializeComponent();
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
GameItems.StartServer();
GameItems.Init();
MainPage = new MainTabbedPage();
}
private GameItem GetItem(string nick, int itemId)
{
if (!GameItems.ContainsKey(itemId) || !IsRunning)
{
return(null);
}
GameItem akt = GameItems[itemId];
if (akt.ItemPlayer == null || akt.ItemPlayer.PlayerClient.ClientName != nick)
{
return(null);
}
return(akt);
}
public static GameItems CreateGameItem(int itemTypeID)
{
GameItems standardItem = _standardGameItems.FirstOrDefault(item => item.ItemTypeID == itemTypeID);
if (standardItem != null)
{
if (standardItem is Weapon)
{
return((standardItem as Weapon).Clone());
}
return(standardItem.Clone());
}
return(null);
}
/// <summary>
/// Removes Game Items from a location (Player Pickup)
/// </summary>
/// <param name="selectedGameItemQuantity">Selected Item</param>
/// <param name="quantity">Quantity of Item</param>
public void RemoveGameItemQuantityFromLocation(GameItemQuantity selectedGameItemQuantity, int quantity)
{
var gameItemQuantity = GameItems.FirstOrDefault(i => i.GameItem.Id == selectedGameItemQuantity.GameItem.Id);
if (gameItemQuantity != null)
{
if (selectedGameItemQuantity.Quantity == quantity)
{
GameItems.Remove(gameItemQuantity);
}
}
UpdateLocationGameItems();
}
public static bool Monster_start(edict_t self)
{
if (GameBase.deathmatch.value != 0)
{
GameUtil.G_FreeEdict(self);
return(false);
}
if ((self.spawnflags & 4) != 0 && 0 == (self.monsterinfo.aiflags & Defines.AI_GOOD_GUY))
{
self.spawnflags &= ~4;
self.spawnflags |= 1;
}
if (0 == (self.monsterinfo.aiflags & Defines.AI_GOOD_GUY))
{
GameBase.level.total_monsters++;
}
self.nextthink = GameBase.level.time + Defines.FRAMETIME;
self.svflags |= Defines.SVF_MONSTER;
self.s.renderfx |= Defines.RF_FRAMELERP;
self.takedamage = Defines.DAMAGE_AIM;
self.air_finished = GameBase.level.time + 12;
self.use = GameUtil.monster_use;
self.max_health = self.health;
self.clipmask = Defines.MASK_MONSTERSOLID;
self.s.skinnum = 0;
self.deadflag = Defines.DEAD_NO;
self.svflags &= ~Defines.SVF_DEADMONSTER;
if (null == self.monsterinfo.checkattack)
{
self.monsterinfo.checkattack = GameUtil.M_CheckAttack;
}
Math3D.VectorCopy(self.s.origin, self.s.old_origin);
if (GameBase.st.item != null && GameBase.st.item.Length > 0)
{
self.item = GameItems.FindItemByClassname(GameBase.st.item);
if (self.item == null)
{
GameBase.gi.Dprintf("monster_start:" + self.classname + " at " + Lib.Vtos(self.s.origin) + " has bad item: " + GameBase.st.item + "\\n");
}
}
if (self.monsterinfo.currentmove != null)
{
self.s.frame = self.monsterinfo.currentmove.firstframe + (Lib.Rand() % (self.monsterinfo.currentmove.lastframe - self.monsterinfo.currentmove.firstframe + 1));
}
return(true);
}
public static void G_SetClientEffects(edict_t ent)
{
int pa_type;
int remaining;
ent.s.effects = 0;
ent.s.renderfx = 0;
if (ent.health <= 0 || GameBase.level.intermissiontime != 0)
{
return;
}
if (ent.powerarmor_time > GameBase.level.time)
{
pa_type = GameItems.PowerArmorType(ent);
if (pa_type == Defines.POWER_ARMOR_SCREEN)
{
ent.s.effects |= Defines.EF_POWERSCREEN;
}
else if (pa_type == Defines.POWER_ARMOR_SHIELD)
{
ent.s.effects |= Defines.EF_COLOR_SHELL;
ent.s.renderfx |= Defines.RF_SHELL_GREEN;
}
}
if (ent.client.quad_framenum > GameBase.level.framenum)
{
remaining = (int)ent.client.quad_framenum - GameBase.level.framenum;
if (remaining > 30 || 0 != (remaining & 4))
{
ent.s.effects |= Defines.EF_QUAD;
}
}
if (ent.client.invincible_framenum > GameBase.level.framenum)
{
remaining = (int)ent.client.invincible_framenum - GameBase.level.framenum;
if (remaining > 30 || 0 != (remaining & 4))
{
ent.s.effects |= Defines.EF_PENT;
}
}
if ((ent.flags & Defines.FL_GODMODE) != 0)
{
ent.s.effects |= Defines.EF_COLOR_SHELL;
ent.s.renderfx |= (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE);
}
}
void RealShoot(GameItem attacker, GameItem target, int num)
{
if (!GameItem.CanShoot(attacker, target))
{
return;
}
if (attacker.NumberOfUnits < num)
{
return;
}
attacker.ChangeNumberOfUnits(-num);
if (attacker.ItemPlayer == target.ItemPlayer)
{
target.ChangeNumberOfUnits(num);
}
else
{
target.ChangeNumberOfUnits(-num);
attacker.ItemPlayer.FinalShoots += num;
if (target.NumberOfUnits == 0)
{
target.ItemPlayer = null;
}
if (target.NumberOfUnits < 0)
{
if (target is Planet)
{
attacker.ItemPlayer.FinalPlanetsCaptured++;
if (target.ItemPlayer != null)
{
target.ItemPlayer.FinalPlanetsLost++;
}
}
target.ItemPlayer = attacker.ItemPlayer;
target.NumberOfUnits = -target.NumberOfUnits;
}
}
if (attacker.NumberOfUnits <= 0 && attacker is Ship)
{
GameItems.Remove(attacker.ItemId);
}
if (target.NumberOfUnits <= 0 && target is Ship)
{
GameItems.Remove(target.ItemId);
}
CheckEndOfGame();
}
static int CheckArmor(edict_t ent, float[] point, float[] normal, int damage, int te_sparks, int dflags)
{
gclient_t client;
int save;
int index;
gitem_t armor;
if (damage == 0)
{
return(0);
}
client = ent.client;
if (client == null)
{
return(0);
}
if ((dflags & Defines.DAMAGE_NO_ARMOR) != 0)
{
return(0);
}
index = GameItems.ArmorIndex(ent);
if (index == 0)
{
return(0);
}
armor = GameItems.GetItemByIndex(index);
gitem_armor_t garmor = (gitem_armor_t)armor.info;
if (0 != (dflags & Defines.DAMAGE_ENERGY))
{
save = (int)Math.Ceiling(garmor.energy_protection * damage);
}
else
{
save = (int)Math.Ceiling(garmor.normal_protection * damage);
}
if (save >= client.pers.inventory[index])
{
save = client.pers.inventory[index];
}
if (save == 0)
{
return(0);
}
client.pers.inventory[index] -= save;
SpawnDamage(te_sparks, point, normal, save);
return(save);
}
/// <summary>
/// Recreate the observable collection and update the locations game items
/// </summary>
public void UpdatedLocationGameItems()
{
ObservableCollection <GameItem> updatedLocationGameItems = new ObservableCollection <GameItem>();
foreach (GameItem GameItem in _gameItems)
{
updatedLocationGameItems.Add(GameItem);
}
GameItems.Clear();
foreach (GameItem gameItem in updatedLocationGameItems)
{
GameItems.Add(gameItem);
}
}
private void DeleteGameItemClick(object sender, RoutedEventArgs e)
{
if (GameItems == null || GameItems.Count < 1 || SelectedGameItem == null)
{
MessageBox.Show("No selected item to delete", "Delete", MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
if (MessageBox.Show("Are you sure to delete selected item?", "Delete", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
{
GameItems.Remove(SelectedGameItem);
FileManagement.SaveListGameData(GameItems);
//Re-load data
LoadData();
}
}
/// <summary>
/// update list of items in a location
/// </summary>
public void UpdateLocationGameItems()
{
ObservableCollection <GameItemQuantity> updatedLocationGameItems = new ObservableCollection <GameItemQuantity>();
foreach (GameItemQuantity gameItemQuantity in _gameItems)
{
updatedLocationGameItems.Add(gameItemQuantity);
}
GameItems.Clear();
foreach (GameItemQuantity gameItemQuantity in updatedLocationGameItems)
{
GameItems.Add(gameItemQuantity);
}
}
