public static void SetFixtureCollision(Fixture fix, EntityCategory cat)
{
switch (cat)
{
case EntityCategory.SCENERY:
SetAsScenery(fix);
break;
case EntityCategory.PLAYER:
SetAsPlayer(fix);
break;
case EntityCategory.PLAYER_SHOT:
SetAsPlayerShot(fix);
break;
case EntityCategory.ENEMY:
SetAsEnemy(fix);
break;
case EntityCategory.ENEMY_SHOT:
SetAsEnemyShot(fix);
break;
default:
break;
}
}
public bool CheckBorder(double x, double y, EntityCategory playerType)
{
switch (playerType)
{
case EntityCategory.Player1:
{
if ((x <= 0 && x >= -350)&&(y>=-20 && y<=250))
{
return true;
break;
}
else
{
return false;
break;
}
}
case EntityCategory.Player2:
{
if ((x >= 0 && x <= 350)&&(y>=-20 && y<=250))
{
return true;
break;
}
else
{
return false;
break;
}
}
default:
return false;
break;
}
}
public DtoActionResult Update(EntityCategory category)
{
var u = GetCategory(category.Id);
if (u == null)
{
return new DtoActionResult {
ErrorMessage = "Category Not Found", Id = 0
}
}
;
var actionResult = new DtoActionResult();
var validationResult = Validate(category, false);
if (validationResult.Success)
{
_uow.CategoryRepository.Update(category, u.Id);
_uow.Save();
actionResult.Success = true;
actionResult.Id = category.Id;
}
else
{
return(new DtoActionResult()
{
ErrorMessage = validationResult.ErrorMessage
});
}
return(actionResult);
}
public override void Collide(Entity entity, EntityCategory entityCategory)
{
if (isExploded)
{
return;
}
Explosion();
foreach (Entity entity1 in scene.entities)
{
if (entity1 == this)
{
continue;
}
if (CollisionCheck.CheckCollision(new RotRectangle(hitbox.RotationRad, hitbox.Center, new Vector2(120, 120)), entity1.Hitbox))
{
if (entity1.GetType() == typeof(Player) || entity1.GetType() == typeof(Cargo))
{
entity1.TakeDamage(1);
}
else
{
entity1.TakeDamage(damage);
}
}
}
}
/// <summary>
/// Handles the <see cref="ToggleButton.Checked"/> event for the "Category" <see
/// cref="RadioButton"/> controls.</summary>
/// <param name="sender">
/// The <see cref="Object"/> where the event handler is attached.</param>
/// <param name="args">
/// A <see cref="RoutedEventArgs"/> object containing event data.</param>
/// <remarks>
/// <b>OnCategoryChecked</b> shows or hides the "Filter" check boxes and updates the
/// "Entity" list view to reflect the selected "Category" radio button.</remarks>
private void OnCategoryChecked(object sender, RoutedEventArgs args)
{
args.Handled = true;
if (!this._initialized)
{
return;
}
EntityCategory category = CurrentCategory;
// determine place targets for all entity classes
if ((this._mode & ShowEntitiesMode.Command) != 0)
{
this._classTargets = Finder.FindAllPlaceTargets(
this._worldState, this._faction, category);
}
// uncheck Placed filter for upgrades since they are never placed
if (category == EntityCategory.Upgrade && PlacedToggle.IsChecked == true)
{
PlacedToggle.IsChecked = null;
}
// show or hide category-specific filters
MobileToggle.Visibility = (category == EntityCategory.Unit ?
Visibility.Visible : Visibility.Collapsed);
CaptureToggle.Visibility = (category == EntityCategory.Terrain ?
Visibility.Visible : Visibility.Collapsed);
UpdateEntities(true);
}
public async Task <ICommandResult <EntityCategory> > DeleteAsync(EntityCategory model)
{
// Validate
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
// Invoke EntityCategoryDeleting subscriptions
foreach (var handler in _broker.Pub <EntityCategory>(this, "EntityCategoryDeleting"))
{
model = await handler.Invoke(new Message <EntityCategory>(model, this));
}
var result = new CommandResult <EntityCategory>();
if (await _entityCategoryStore.DeleteAsync(model))
{
// Invoke EntityCategoryDeleted subscriptions
foreach (var handler in _broker.Pub <EntityCategory>(this, "EntityCategoryDeleted"))
{
model = await handler.Invoke(new Message <EntityCategory>(model, this));
}
// Return success
return(result.Success());
}
return(result.Failed(new CommandError("An unknown error occurred whilst attempting to delete an entity & category relationship")));
}
public Player(EntityCategory playerType, string name = "Player")
{
Name = name;
PlayerType = playerType;
Resources = new PlayerData();
Guns = new List<Gun>();
}
internal static string ToSerializedValue(this EntityCategory value)
{
switch (value)
{
case EntityCategory.Location:
return("location");
case EntityCategory.Organization:
return("organization");
case EntityCategory.Person:
return("person");
case EntityCategory.Quantity:
return("quantity");
case EntityCategory.Datetime:
return("datetime");
case EntityCategory.Url:
return("url");
case EntityCategory.Email:
return("email");
}
return(null);
}
public override void Collide(Entity entity, EntityCategory entityCategory)
{
if (!isActivated)
{
isActivated = true;
}
}
/// <summary>
/// Updates the "Stack Preview" panel for the specified <see cref="EntityCategory"/>.
/// </summary>
/// <param name="category">
/// An <see cref="EntityCategory"/> value indicating the entity stack to preview.</param>
/// <exception cref="InvalidEnumArgumentException">
/// <paramref name="category"/> is <see cref="EntityCategory.Upgrade"/> or an invalid <see
/// cref="EntityCategory"/> value.</exception>
/// <remarks>
/// <b>UpdatePreview</b> shows overlaid images for all entities if <paramref
/// name="category"/> equals <b>Effect</b> or <b>Terrain</b>, and only the image for the
/// topmost entity if <paramref name="category"/> equals <b>Unit</b>.</remarks>
private void UpdatePreview(EntityCategory category)
{
switch (category)
{
case EntityCategory.Terrain:
// show entire stack for terrains
TerrainPreview.Show(this._terrains);
break;
case EntityCategory.Unit:
// show only topmost entity for units
int index = this._units.Count - 1;
if (index < 0)
{
EntityPreview.Clear();
}
else
{
EntityPreview.Show(this._units[index]);
}
break;
case EntityCategory.Effect:
// show entire stack for effects
EntityPreview.Show(this._effects);
break;
default:
ThrowHelper.ThrowInvalidEnumArgumentException(
"category", (int)category, typeof(EntityCategory));
break;
}
}
// PUT api/entitycategory/
public HttpResponseMessage Put([FromBody] EntityCategory value, string filter = null)
{
ServerValidationInfo vi = null;
if (!ModelState.IsValid)
{
vi = new ServerValidationInfo(ModelState);
}
if (filter == null)
{
context.Entry(value).State = System.Data.EntityState.Modified;
}
else
{
var old = context.EntityCategories.SingleOrDefault(queryBuider.CreateWhere(filter));
old.Id = value.Id;
old.Code = value.Code;
old.Name = value.Name;
}
if (vi != null && vi.ContainsError)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, vi));
}
var result = context.SaveChanges() > 0;
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
public Dictionary <AnimationType, string> animationNameList; //애니메이션 클립 리스트.
/// <summary>
/// AnimationList,animationNameList를 각 객체에 맞게 세팅한다.
/// </summary>
public override void Init(EntityCategory category)
{
base.Init(category);
this.animationNameList = new Dictionary <AnimationType, string>();
this.animationNameList.Add(AnimationType.Attack, "lv" + currLevel.ToString() + "_attack");
}
/// <summary>
/// Handles the <see cref="ToggleButton.Checked"/> event for the "Category" <see
/// cref="RadioButton"/> controls on the <see cref="OtherTab"/> page.</summary>
/// <param name="sender">
/// The <see cref="Object"/> where the event handler is attached.</param>
/// <param name="args">
/// A <see cref="RoutedEventArgs"/> object containing event data.</param>
/// <remarks>
/// <b>OnCategoryChecked</b> sets the current <see cref="EntityCategory"/> to the value
/// indicated by the selected "Category" radio button, and updates all controls on the <see
/// cref="OtherTab"/> page to reflect the current category.</remarks>
private void OnCategoryChecked(object sender, RoutedEventArgs args)
{
args.Handled = true;
if (!this._initialized || this._area == null)
{
return;
}
// switch category (default to Unit)
if (EffectToggle.IsChecked == true)
{
this._currentCategory = EntityCategory.Effect;
this._currentClasses = MasterSection.Instance.Entities.Effects;
this._currentEntities = this._effects;
}
else
{
this._currentCategory = EntityCategory.Unit;
this._currentClasses = MasterSection.Instance.Entities.Units;
this._currentEntities = this._units;
}
// show all available entity classes
AvailableEntityList.ItemsSource = this._currentClasses.Keys;
// add current entity site stack
EntityList.Items.Clear();
foreach (EntityTemplate template in this._currentEntities)
{
CreateEntityItem(EntityList, template);
}
// select first entity class, if any
bool anyClasses = (AvailableEntityList.Items.Count > 0);
if (anyClasses)
{
AvailableEntityList.SelectedIndex = 0;
}
// select first entity template, if any
bool anyEntities = (EntityList.Items.Count > 0);
if (anyEntities)
{
EntityList.SelectedIndex = 0;
}
// enable or disable entity list controls
AddEntityButton.IsEnabled = anyClasses;
ChangeEntityButton.IsEnabled = anyEntities;
RemoveEntityButton.IsEnabled = anyEntities;
MoveEntityDownButton.IsEnabled = anyEntities;
MoveEntityUpButton.IsEnabled = anyEntities;
// create entity stack preview
UpdatePreview(this._currentCategory);
}
protected async Task <int> DeleteAllContentsOfEntityCategoryAsync(EntityCategory entity)
{
var id = new SqlParameter("id", entity.Id);
var sql = $"DELETE FROM {nameof(EntityCategoryContent)} WHERE " +
$"{nameof(EntityCategoryContent.CategoryId)}=@{id.ParameterName}";
var result = await context.Database.ExecuteSqlRawAsync(sql, id);
return(result);
}
public DtoActionResult Put(int id, EntityCategory category)
{
category.Id = id;
var result = _categoryService.Update(category);
if (result == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
return(result);
}
public static bool LLCategoryUpdate(EntityCategory cat)
{
if (cat.categoryName != "")
{
return(DALCategory.CategoryUpdate(cat));
}
else
{
return(false);
}
}
public EntityData GetEntityData(EntityCategory category)
{
foreach (KeyValuePair <int, EntityData> kv in entityData)
{
if (kv.Value.entCategory == category)
{
return(kv.Value);
}
}
return(null);
}
// Data Acceess Layer Logic Layer üzerinden erişilen bir katmandır ve SQL sorgularının çalıştırıldığı katman olarak geçer
// CRUD CREATE READ UPDATE DELETE operasyonları bu katmanda yazılır
public static int CategorySave(EntityCategory cat)
{
OleDbCommand komut2 = new OleDbCommand("insert into CategoryTable (CategoryName) values (@p1)", Connection.baglanti);
if (komut2.Connection.State != ConnectionState.Open)
{
komut2.Connection.Open();
}
komut2.Parameters.AddWithValue("@p1", cat.categoryName);
return(komut2.ExecuteNonQuery());
}
public EntityModel(int id, string category, string eType, int hp, int level, int power, float range, float speed, string prefabName)
{
this.ID = id;
this.entCategory = (EntityCategory)System.Enum.Parse(typeof(EntityCategory), category);
this.enType = (EntityType)System.Enum.Parse(typeof(EntityType), eType);
this.HP = hp;
this.Level = level;
this.AttackPower = power;
this.SearchRange = range;
this.AttackSpeed = speed;
this.Prefab = prefabName;
}
public override void Collide(Entity entity, EntityCategory entityCategory)
{
if (!isActivated)
{
if (entityCategory == EntityCategory.ActiveAbility)
{
isExploded = true;
}
isActivated = true;
}
}
public static bool CategoryUpdate(EntityCategory cat)
{
OleDbCommand komut4 = new OleDbCommand("Update CategoryTable set CategoryName=@p1 where CategoryID=@p2", Connection.baglanti);
if (komut4.Connection.State != ConnectionState.Open)
{
komut4.Connection.Open();
}
komut4.Parameters.AddWithValue("@p1", cat.categoryName);
komut4.Parameters.AddWithValue("@p2", cat.categoryId);
return(komut4.ExecuteNonQuery() > 0);
}
// Logic Layer ana form üzerinden erişilen bir katmandır ve gerekli mantıksal kontrollerin katman olarak geçer
// Gerekli kontrolleri başarılı bir şekilde geçen Logic Methodlar Data Access Layerdan uygun methodu çağırarak programın çalışmasına devam edilir
public static int LLCategorySave(EntityCategory cat)
{
if (cat.categoryName != "")
{
//burada sifreyi sifrele
return(DALCategory.CategorySave(cat));
}
else
{
return(-1);
}
}
public override void Collide(Entity entity, EntityCategory entityCategory)
{
if (damageTick)
{
switch (entityCategory)
{
case EntityCategory.Enemy:
entity.TakeDamage(damagePerTick);
break;
}
}
}
/// <summary>
/// Handles the <see cref="ToggleButton.Checked"/> event for the "Category" <see
/// cref="RadioButton"/> controls.</summary>
/// <param name="sender">
/// The <see cref="Object"/> where the event handler is attached.</param>
/// <param name="args">
/// A <see cref="RoutedEventArgs"/> object containing event data.</param>
/// <remarks>
/// <b>OnCategoryChecked</b> updates the "Entity Class" list view to reflect the selected
/// "Category" radio button, and then selects the first item in that list view, if any.
/// </remarks>
private void OnCategoryChecked(object sender, RoutedEventArgs args)
{
args.Handled = true;
// switch category (default to Unit)
EntityCategory category = EntityCategory.Unit;
if (UnitToggle.IsChecked == true)
{
category = EntityCategory.Unit;
this._classTargets = this._unitTargets;
}
else if (TerrainToggle.IsChecked == true)
{
category = EntityCategory.Terrain;
this._classTargets = this._terrainTargets;
}
else
{
Debug.Fail("ShowPlacements.OnCategoryChecked: No Category button checked.");
category = EntityCategory.Unit;
this._classTargets = this._unitTargets;
}
// get all buildable classes of current category
var buildableClasses = this._faction.GetBuildableClasses(category);
EntitySection entities = MasterSection.Instance.Entities;
ClassList.Items.Clear();
foreach (var pair in this._classTargets)
{
// get entity class for current target, if any
EntityClass entityClass = entities.GetEntity(pair.Key);
if (entityClass == null)
{
continue;
}
// check if specified faction can build entity class
bool canBuild = buildableClasses.ContainsKey(entityClass.Id);
string check = (canBuild ? CheckMark : "");
ClassList.Items.Add(new ClassListItem(entityClass, check));
}
// select first entity class, if any
if (ClassList.Items.Count > 0)
{
ClassList.SelectedIndex = 0;
}
}
public override void Collide(Entity entity, EntityCategory entityCategory)
{
if (collidedEntities.Contains(entity))
{
return;
}
switch (entityCategory)
{
case EntityCategory.Enemy:
(entity as BaseEnemy).TakeDamage(damage);
collidedEntities.Add(entity);
break;
}
}
public void SetAttributeForEntityCategory(EntityCategory entityCategory, AttributeCategory attributeCategory)
{
if (!m_entityCategoryAttributeDict.ContainsKey(entityCategory))
{
m_entityCategoryAttributeDict[entityCategory] = new HashSet <AttributeCategory>();
}
var attributeCategories = m_entityCategoryAttributeDict[entityCategory];
if (!attributeCategories.Contains(attributeCategory))
{
attributeCategories.Add(attributeCategory);
}
}
public async Task <ICommandResult <EntityCategory> > CreateAsync(EntityCategory model)
{
// Validate
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
// We are creating - ensure we don't have an id
if (model.Id > 0)
{
throw new ArgumentOutOfRangeException(nameof(model.Id));
}
if (model.CategoryId <= 0)
{
throw new ArgumentOutOfRangeException(nameof(model.CategoryId));
}
if (model.EntityId <= 0)
{
throw new ArgumentOutOfRangeException(nameof(model.EntityId));
}
// Invoke EntityCategoryCreating subscriptions
foreach (var handler in _broker.Pub <EntityCategory>(this, "EntityCategoryCreating"))
{
model = await handler.Invoke(new Message <EntityCategory>(model, this));
}
// Create result
var result = new CommandResult <EntityCategory>();
// Create relationship
var entityCategory = await _entityCategoryStore.CreateAsync(model);
if (entityCategory != null)
{
// Invoke EntityCategoryCreated subscriptions
foreach (var handler in _broker.Pub <EntityCategory>(this, "EntityCategoryCreated"))
{
entityCategory = await handler.Invoke(new Message <EntityCategory>(entityCategory, this));
}
// Return success
return(result.Success(entityCategory));
}
return(result.Failed(new CommandError("An unknown error occurred whilst attempting to create an entity & category relationship")));
}
public override void Collide(Entity entity, EntityCategory entityCategory)
{
if (carFront.CheckCollision(entity))
{
entity.Velocity += velocity;
//entity.noCollision = true;
switch (entityCategory)
{
case EntityCategory.Player: (entity as Player).Move(velocity * 1.05f); break;
case EntityCategory.Enemy: entity.Velocity += velocity; (entity as BaseEnemy).wasPushed = true; break;
}
}
}
public async Task UpdateEntityCategoryTransactionAsync(EntityCategory entity,
UpdateEntityCategoryModel model)
{
if (model.NewEntityCategoryContents != null)
{
CreateEntityCategoryContents(model.NewEntityCategoryContents, entity);
}
if (model.UpdateEntityCategoryContents != null)
{
UpdateEntityCategoryContents(model.UpdateEntityCategoryContents, entity.Id);
}
if (model.DeleteEntityCategoryContentLangs != null)
{
await DeleteContentsOfCategoryAsync(model.DeleteEntityCategoryContentLangs, entity.Id);
}
}
//Score entity type in 100
private static int TextAnalysisConfidenceScore(EntityCategory entityCategory, string textType)
{
switch (textType)
{
case "Sports":
return(SportsTextAnalysisConfidenceScore(entityCategory));
case "Science":
return(ScienceTextAnalysisConfidenceScore(entityCategory));
case "Energy":
return(EnergyTextAnalysisConfidenceScore(entityCategory));
default:
return(DefaultTextAnalysisConfidenceScore(entityCategory));
}
}
private void BtnCatDelete_Click(object sender, EventArgs e)
{
// Sadece ID kontrol etmemiz yeterli VeriTabanından Kayıtlar Nesneyi eşsiz yapan bir özelliği üzerinden silinirler
// ID her kategorinin benzersiz sahip olduğu bir özelliktir
if (TxtCatId.Text != "")
{
EntityCategory ent = new EntityCategory();
ent.categoryId = int.Parse(TxtCatId.Text);
LogicCategory.LLCategoryDelete(ent.categoryId);
MessageBox.Show("Kategori Başarılı Bir Şekilde Silindi");
TxtCatName.Text = "";
}
else
{
MessageBox.Show("Id Alanını Boş Bırakmayınız");
}
}
// POST api/entitycategory/
public HttpResponseMessage Post([FromBody] EntityCategory value)
{
ServerValidationInfo vi = null;
if (!ModelState.IsValid)
{
vi = new ServerValidationInfo(ModelState);
}
if (vi != null && vi.ContainsError)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, vi));
}
context.Entry(value).State = System.Data.EntityState.Added;
context.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, value));
}
public static void SetFixtureCollision(Fixture fix, EntityCategory cat)
{
switch (cat) {
case EntityCategory.SCENERY:
SetAsScenery(fix);
break;
case EntityCategory.PLAYER:
SetAsPlayer(fix);
break;
case EntityCategory.PLAYER_SHOT:
SetAsPlayerShot(fix);
break;
case EntityCategory.ENEMY:
SetAsEnemy(fix);
break;
case EntityCategory.ENEMY_SHOT:
SetAsEnemyShot(fix);
break;
default :
break;
}
}
/// <summary>
/// Constructs an entity type.
/// </summary>
public EntityType(string entityTypeName, EntityCategory category, int version,
CreateInstanceDelegate createInstanceDelegate, IEnumerable<EntityPropertyDefinition> propertyDefinitions)
{
if (entityTypeName == null) throw new ArgumentNullException("entityTypeName");
if (createInstanceDelegate == null) throw new ArgumentNullException("createInstanceDelegate");
if (propertyDefinitions == null) throw new ArgumentNullException("propertyDefinitions");
//
this.name = entityTypeName;
this.category = category;
this.repositoryVersion = version;
this.createInstanceDelegate = createInstanceDelegate;
this.propertyDefinitions = new List<EntityPropertyDefinition>();
// Sort property definitions:
// EntityFieldDefinitions first, EntityInnerObjectsDefinition afterwards
foreach (EntityPropertyDefinition propertyDef in propertyDefinitions)
if (propertyDef is EntityFieldDefinition) this.propertyDefinitions.Add(propertyDef);
foreach (EntityPropertyDefinition propertyDef in propertyDefinitions)
if (propertyDef is EntityInnerObjectsDefinition) this.propertyDefinitions.Add(propertyDef);
}
public static List<Box> CreateBuilding(World world, Gameplay gameplay, EntityCategory playerType)
{
List<Box> boxes = new List<Box>();
Terrain terrain = new Terrain(world);
bool flag = true;
switch (playerType)
{
case (EntityCategory.Player1):
{
float x, y;
y = terrain.GetHeight(-300);
float bw, bh;
bw = 6;
bh = 3;
Vector2 position;
Vector2 size;
Box box;
for (int i = 0; i < 8; i++)
{
x = -300;
for (int j = 0; j < 3; j++)
{
if (j >= 1 && i>=1)
{
flag = false;
}
CreateNew(flag, terrain, x, y, bw, bh, boxes, world, gameplay);
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "base-block", true, gameplay.Player1, BASE_STRENGTH);
boxes.Add(box);
x += bw;
}
y += bh;
}
flag = true;
x = -303;
y = terrain.GetHeight(x) + 24f;
for (int i = 0; i < 4; i++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "base-block", true, gameplay.Player1, BASE_STRENGTH);
boxes.Add(box);
x += bw;
}
x = -303;
y = terrain.GetHeight(x) + 27f;
for (int i = 0; i < 3; i++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "base-block", true, gameplay.Player1, BASE_STRENGTH);
boxes.Add(box);
x += bw + bw / 2f;
}
y = terrain.GetHeight(-230);
for (int i = 0; i < 8; i++)
{
x = -230;
for (int j = 0; j < 3; j++)
{
if (j >= 1 && i >= 1)
{
flag = false;
}
CreateNew(flag, terrain, x, y, bw, bh, boxes, world, gameplay);
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "block2", true, gameplay.Player1,200);
boxes.Add(box);
x += bw;
}
y += bh;
}
x = -233;
y = terrain.GetHeight(-233)+24f;
for (int i = 0; i < 4; i++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "block2", true, gameplay.Player1,200);
boxes.Add(box);
x += bw;
}
x = -233;
y = terrain.GetHeight(-233)+27f;
for (int i = 0; i < 3; i++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "block2", true, gameplay.Player1,200);
boxes.Add(box);
x += bw + bw / 2f;
}
flag = true;
y = terrain.GetHeight(-236);
for (int i = 0; i < 5; i++)
{
x = -236;
for (int j = 0; j < 8; j++)
{
if (j >= 1 && i >= 1)
{
flag = false;
}
CreateNew(flag, terrain, x, y, bw, bh, boxes, world, gameplay);
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "block3", true, gameplay.Player1);
boxes.Add(box);
x -= bw;
}
y += bh;
}
flag = true;
break;
}
case (EntityCategory.Player2):
{
float x, y;
y = terrain.GetHeight(300);
float bw, bh;
bw = 6;
bh = 3;
Vector2 position;
Vector2 size;
Box box;
for (int i = 0; i < 8; i++)
{
x = 300;
for (int j = 0; j < 3; j++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "base-block", true, gameplay.Player2, BASE_STRENGTH);
boxes.Add(box);
x -= bw;
}
y += bh;
}
x = 303;
y = terrain.GetHeight(300)+24f;
for (int i = 0; i < 4; i++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "base-block", true, gameplay.Player2, BASE_STRENGTH);
boxes.Add(box);
x -= bw;
}
x = 303;
y = terrain.GetHeight(300)+27f;
for (int i = 0; i < 3; i++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "base-block", true, gameplay.Player2, BASE_STRENGTH);
boxes.Add(box);
x -= bw + bw / 2f;
}
y = terrain.GetHeight(230);
for (int i = 0; i < 8; i++)
{
x = 230;
for (int j = 0; j < 3; j++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "block2", true, gameplay.Player2,200);
boxes.Add(box);
x -= bw;
}
y += bh;
}
x = 233;
y = terrain.GetHeight(233)+24f;
for (int i = 0; i < 4; i++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "block2", true, gameplay.Player2,200);
boxes.Add(box);
x -= bw;
}
x = 233;
y = terrain.GetHeight(233)+27f;
for (int i = 0; i < 3; i++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "block2", true, gameplay.Player2,200);
boxes.Add(box);
x -= bw + bw / 2f;
}
y = terrain.GetHeight(236);
for (int i = 0; i < 5; i++)
{
x = 236;
for (int j = 0; j < 8; j++)
{
position = new Vector2(x, y);
size = new Vector2(bw, bh);
box = new Box(world, position, size, "block3", true, gameplay.Player2);
boxes.Add(box);
x += bw;
}
y += bh;
}
break;
}
}
return boxes;
}
