mirror of
https://github.com/SoDOff-Project/sodoff.git
synced 2025-10-11 08:18:49 -07:00
1244 lines
51 KiB
C#
1244 lines
51 KiB
C#
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using sodoff.Attributes;
|
|
using sodoff.Model;
|
|
using sodoff.Schema;
|
|
using sodoff.Services;
|
|
using sodoff.Util;
|
|
using System;
|
|
|
|
namespace sodoff.Controllers.Common;
|
|
public class ContentController : Controller {
|
|
|
|
private readonly DBContext ctx;
|
|
private KeyValueService keyValueService;
|
|
private ItemService itemService;
|
|
private MissionService missionService;
|
|
private RoomService roomService;
|
|
private AchievementService achievementService;
|
|
private InventoryService inventoryService;
|
|
private Random random = new Random();
|
|
public ContentController(DBContext ctx, KeyValueService keyValueService, ItemService itemService, MissionService missionService, RoomService roomService, AchievementService achievementService, InventoryService inventoryService) {
|
|
this.ctx = ctx;
|
|
this.keyValueService = keyValueService;
|
|
this.itemService = itemService;
|
|
this.missionService = missionService;
|
|
this.roomService = roomService;
|
|
this.achievementService = achievementService;
|
|
this.inventoryService = inventoryService;
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetDefaultNameSuggestion")]
|
|
[VikingSession(Mode=VikingSession.Modes.VIKING_OR_USER, UseLock=false)]
|
|
public IActionResult GetDefaultNameSuggestion(User? user, Viking? viking) {
|
|
string[] adjs = { //Adjectives used to generate suggested names
|
|
"Adventurous", "Active", "Alert", "Attentive",
|
|
"Beautiful", "Berkian", "Berserker", "Bold", "Brave",
|
|
"Caring", "Cautious", "Creative", "Curious",
|
|
"Dangerous", "Daring", "Defender",
|
|
"Elder", "Exceptional", "Exquisite",
|
|
"Fearless", "Fighter", "Friendly",
|
|
"Gentle", "Grateful", "Great",
|
|
"Happy", "Honorable", "Hunter",
|
|
"Insightful", "Intelligent",
|
|
"Jolly", "Joyful", "Joyous",
|
|
"Kind", "Kindly",
|
|
"Legendary", "Lovable", "Lovely",
|
|
"Marvelous", "Magnificent",
|
|
"Noble", "Nifty", "Neat",
|
|
"Outcast", "Outgoing", "Organized",
|
|
"Planner", "Playful", "Pretty",
|
|
"Quick", "Quiet",
|
|
"Racer", "Random", "Resilient",
|
|
"Scientist", "Seafarer", "Smart", "Sweet",
|
|
"Thinker", "Thoughtful",
|
|
"Unafraid", "Unique",
|
|
"Valiant", "Valorous", "Victor", "Victorious", "Viking",
|
|
"Winner", "Warrior", "Wise",
|
|
"Young", "Youthful",
|
|
"Zealous", "Zealot"
|
|
};
|
|
|
|
if (user is null)
|
|
user = viking.User;
|
|
string uname = user.Username;
|
|
|
|
Random choice = new Random(); //Randomizer for selecting random adjectives
|
|
|
|
List<string> suggestions = new();
|
|
AddSuggestion(choice, uname, suggestions);
|
|
|
|
for (int i = 0; i < 5; i++)
|
|
AddSuggestion(choice, GetNameSuggestion(choice, uname, adjs), suggestions);
|
|
|
|
return Ok(new DisplayNameUniqueResponse {
|
|
Suggestions = new SuggestionResult {
|
|
Suggestion = suggestions.ToArray()
|
|
}
|
|
});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/ValidateName")]
|
|
public IActionResult ValidateName([FromForm] string nameValidationRequest) {
|
|
// Check if name populated
|
|
NameValidationRequest request = XmlUtil.DeserializeXml<NameValidationRequest>(nameValidationRequest);
|
|
|
|
if (request.Category == NameCategory.Default) {
|
|
// This is an avatar we are checking
|
|
// Check if viking exists
|
|
bool exists = ctx.Vikings.Count(e => e.Name == request.Name) > 0;
|
|
NameValidationResult result = exists ? NameValidationResult.NotUnique : NameValidationResult.Ok;
|
|
return Ok(new NameValidationResponse { Result = result});
|
|
|
|
} else {
|
|
// TODO: pets, groups, default
|
|
return Ok();
|
|
}
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetKeyValuePair")]
|
|
public Schema.PairData? GetKeyValuePair([FromForm] string apiToken, [FromForm] int pairId) {
|
|
// Find session by apiToken
|
|
Session? session = ctx.Sessions.FirstOrDefault(s => s.ApiToken == apiToken);
|
|
if (session is null)
|
|
return null;
|
|
|
|
// Get the pair
|
|
Model.PairData? pair = keyValueService.GetPairData(session.User, session.Viking, null, pairId);
|
|
|
|
return keyValueService.ModelToSchema(pair);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/SetKeyValuePair")]
|
|
public IActionResult SetKeyValuePair([FromForm] string apiToken, [FromForm] int pairId, [FromForm] string contentXML) {
|
|
Schema.PairData schemaData = XmlUtil.DeserializeXml<Schema.PairData>(contentXML);
|
|
|
|
// Get the session
|
|
Session? session = ctx.Sessions.FirstOrDefault(s => s.ApiToken == apiToken);
|
|
if (session is null)
|
|
return Ok(false);
|
|
|
|
bool result = keyValueService.SetPairData(session.User, session.Viking, null, pairId, schemaData);
|
|
|
|
return Ok(result);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetKeyValuePairByUserID")]
|
|
public Schema.PairData? GetKeyValuePairByUserID([FromForm] string apiToken, [FromForm] int pairId, [FromForm] string userId) {
|
|
Session? session = ctx.Sessions.FirstOrDefault(s => s.ApiToken == apiToken);
|
|
if (session is null)
|
|
return null;
|
|
|
|
Model.PairData? pair = keyValueService.GetPairData(session.User, session.Viking, userId, pairId);
|
|
|
|
return keyValueService.ModelToSchema(pair);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/SetKeyValuePairByUserID")]
|
|
public IActionResult SetKeyValuePairByUserID([FromForm] string apiToken, [FromForm] int pairId, [FromForm] string userId, [FromForm] string contentXML) {
|
|
Schema.PairData schemaData = XmlUtil.DeserializeXml<Schema.PairData>(contentXML);
|
|
|
|
// Get the session
|
|
Session? session = ctx.Sessions.FirstOrDefault(s => s.ApiToken == apiToken);
|
|
if (session is null || string.IsNullOrEmpty(userId))
|
|
return Ok(false);
|
|
|
|
bool result = keyValueService.SetPairData(session.User, session.Viking, userId, pairId, schemaData);
|
|
|
|
return Ok(result);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetCommonInventory")]
|
|
[VikingSession(Mode=VikingSession.Modes.VIKING_OR_USER, UseLock=false)]
|
|
public IActionResult GetCommonInventory(User? user, Viking? viking) {
|
|
if (viking != null) {
|
|
return Ok( inventoryService.GetCommonInventoryData(viking) );
|
|
} else {
|
|
// TODO: placeholder - return 8 viking slot items
|
|
return Ok(new CommonInventoryData {
|
|
UserID = Guid.Parse(user.Id),
|
|
Item = new UserItemData[] {
|
|
new UserItemData {
|
|
UserInventoryID = 0,
|
|
ItemID = 7971,
|
|
Quantity = 8,
|
|
Uses = -1,
|
|
ModifiedDate = new DateTime(DateTime.Now.Ticks),
|
|
Item = itemService.GetItem(7971)
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/GetCommonInventory")]
|
|
[VikingSession(UseLock=false)]
|
|
public IActionResult GetCommonInventoryV2(Viking viking) {
|
|
return Ok(inventoryService.GetCommonInventoryData(viking));
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/SetCommonInventory")]
|
|
[VikingSession]
|
|
public IActionResult SetCommonInventory(Viking viking, [FromForm] string commonInventoryRequestXml) {
|
|
CommonInventoryRequest[] request = XmlUtil.DeserializeXml<CommonInventoryRequest[]>(commonInventoryRequestXml);
|
|
List<CommonInventoryResponseItem> responseItems = new();
|
|
|
|
// SetCommonInventory can remove any number of items from the inventory, this checks if it's possible
|
|
foreach (var req in request) {
|
|
if (req.Quantity >= 0) continue;
|
|
int inventorySum = viking.Inventory.InventoryItems.Sum(e => {if (e.ItemId == req.ItemID) return e.Quantity; return 0;});
|
|
if (inventorySum < -req.Quantity)
|
|
return Ok(new CommonInventoryResponse { Success = false });
|
|
}
|
|
|
|
// Now that we know the request is valid, update the inventory
|
|
foreach (var req in request) {
|
|
if (req.ItemID == 0) continue; // Do not save a null item
|
|
|
|
if (inventoryService.ItemNeedUniqueInventorySlot((int)req.ItemID)) {
|
|
// if req.Quantity < 0 remove unique items
|
|
for (int i=req.Quantity; i<0; ++i) {
|
|
InventoryItem? item = viking.Inventory.InventoryItems.FirstOrDefault(e => e.ItemId == req.ItemID && e.Quantity>0);
|
|
item.Quantity--;
|
|
}
|
|
// if req.Quantity > 0 add unique items
|
|
for (int i=0; i<req.Quantity; ++i) {
|
|
responseItems.Add(
|
|
inventoryService.AddItemToInventoryAndGetResponse(viking, (int)req.ItemID!, 1)
|
|
);
|
|
}
|
|
} else {
|
|
if (req.Quantity > 0) {
|
|
responseItems.Add(
|
|
inventoryService.AddItemToInventoryAndGetResponse(viking, (int)req.ItemID!, req.Quantity)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
CommonInventoryResponse response = new CommonInventoryResponse {
|
|
Success = true,
|
|
CommonInventoryIDs = responseItems.ToArray()
|
|
};
|
|
|
|
ctx.SaveChanges();
|
|
return Ok(response);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/UseInventory")]
|
|
[VikingSession]
|
|
public IActionResult UseInventory(Viking viking, [FromForm] int userInventoryId, [FromForm] int numberOfUses) {
|
|
InventoryItem? item = viking.Inventory.InventoryItems.FirstOrDefault(e => e.Id == userInventoryId);
|
|
if (item is null)
|
|
return Ok(false);
|
|
if (item.Quantity < numberOfUses)
|
|
return Ok(false);
|
|
|
|
item.Quantity -= numberOfUses;
|
|
ctx.SaveChanges();
|
|
return Ok(true);
|
|
}
|
|
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetAuthoritativeTime")]
|
|
public IActionResult GetAuthoritativeTime() {
|
|
return Ok(new DateTime(DateTime.Now.Ticks));
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/SetAvatar")]
|
|
[VikingSession]
|
|
public IActionResult SetAvatar(Viking viking, [FromForm] string contentXML) {
|
|
AvatarData avatarData = XmlUtil.DeserializeXml<AvatarData>(contentXML);
|
|
foreach (AvatarDataPart part in avatarData.Part) {
|
|
if (part.PartType == "Version") {
|
|
if (part.Offsets[0].X < 6 || part.Offsets[0].X == 6 && part.Offsets[0].Y < 1) {
|
|
// do not allow to save avatar data from old clients (avatar data version < 6.1) ... it's broke profile on 3.31
|
|
// but return as true to trick the client to avoid re-show change viking name dialog
|
|
// TODO: maybe better set pair AvatarNameCustomizationDone -> 1 (in "2017" pairs) and return error here?
|
|
return Ok(new SetAvatarResult {
|
|
Success = true,
|
|
DisplayName = viking.Name,
|
|
StatusCode = AvatarValidationResult.Valid
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
viking.AvatarSerialized = contentXML;
|
|
ctx.SaveChanges();
|
|
|
|
return Ok(new SetAvatarResult {
|
|
Success = true,
|
|
DisplayName = viking.Name,
|
|
StatusCode = AvatarValidationResult.Valid
|
|
});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/CreatePet")]
|
|
[VikingSession]
|
|
public IActionResult CreatePet(Viking viking, [FromForm] string request) {
|
|
RaisedPetRequest raisedPetRequest = XmlUtil.DeserializeXml<RaisedPetRequest>(request);
|
|
// TODO: Investigate SetAsSelectedPet and UnSelectOtherPets - they don't seem to do anything
|
|
|
|
// Update the RaisedPetData with the info
|
|
String dragonId = Guid.NewGuid().ToString();
|
|
raisedPetRequest.RaisedPetData.IsPetCreated = true;
|
|
raisedPetRequest.RaisedPetData.RaisedPetID = 0; // Initially make zero, so the db auto-fills
|
|
raisedPetRequest.RaisedPetData.EntityID = Guid.Parse(dragonId);
|
|
raisedPetRequest.RaisedPetData.Name = string.Concat("Dragon-", dragonId.AsSpan(0, 8)); // Start off with a random name
|
|
raisedPetRequest.RaisedPetData.IsSelected = false; // The api returns false, not sure why
|
|
raisedPetRequest.RaisedPetData.CreateDate = new DateTime(DateTime.Now.Ticks);
|
|
raisedPetRequest.RaisedPetData.UpdateDate = new DateTime(DateTime.Now.Ticks);
|
|
int imageSlot = (viking.Images.Select(i => i.ImageSlot).DefaultIfEmpty(-1).Max() + 1);
|
|
raisedPetRequest.RaisedPetData.ImagePosition = imageSlot;
|
|
// NOTE: Placing an egg into a hatchery slot calls CreatePet, but doesn't SetImage.
|
|
// NOTE: We need to force create an image slot because hatching multiple eggs at once would create dragons with the same slot
|
|
Image image = new Image {
|
|
ImageType = "EggColor", // NOTE: The game doesn't seem to use anything other than EggColor.
|
|
ImageSlot = imageSlot,
|
|
Viking = viking,
|
|
};
|
|
// Save the dragon in the db
|
|
Dragon dragon = new Dragon {
|
|
EntityId = Guid.NewGuid().ToString(),
|
|
Viking = viking,
|
|
RaisedPetData = XmlUtil.SerializeXml(raisedPetRequest.RaisedPetData),
|
|
};
|
|
|
|
if (raisedPetRequest.SetAsSelectedPet == true) {
|
|
viking.SelectedDragon = dragon;
|
|
ctx.Update(viking);
|
|
}
|
|
ctx.Dragons.Add(dragon);
|
|
ctx.Images.Add(image);
|
|
ctx.SaveChanges();
|
|
|
|
if (raisedPetRequest.CommonInventoryRequests is not null) {
|
|
foreach (var req in raisedPetRequest.CommonInventoryRequests) {
|
|
InventoryItem? item = viking.Inventory.InventoryItems.FirstOrDefault(e => e.ItemId == req.ItemID);
|
|
|
|
//Does the item exist in the user's inventory?
|
|
if (item is null) continue; //If not, skip it.
|
|
|
|
if (item.Quantity + req.Quantity >= 0 ) { //If so, can we update it appropriately?
|
|
//We can. Do so.
|
|
item.Quantity += req.Quantity; //Note that we use += here because req.Quantity is negative.
|
|
ctx.SaveChanges();
|
|
}
|
|
}
|
|
}
|
|
|
|
return Ok(new CreatePetResponse {
|
|
RaisedPetData = GetRaisedPetDataFromDragon(dragon)
|
|
});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("v3/ContentWebService.asmx/SetRaisedPet")]
|
|
[VikingSession]
|
|
public IActionResult SetRaisedPet(Viking viking, [FromForm] string request, [FromForm] bool? import) {
|
|
RaisedPetRequest raisedPetRequest = XmlUtil.DeserializeXml<RaisedPetRequest>(request);
|
|
|
|
// Find the dragon
|
|
Dragon? dragon = viking.Dragons.FirstOrDefault(e => e.Id == raisedPetRequest.RaisedPetData.RaisedPetID);
|
|
if (dragon is null) {
|
|
return Ok(new SetRaisedPetResponse {
|
|
RaisedPetSetResult = RaisedPetSetResult.Invalid
|
|
});
|
|
}
|
|
|
|
dragon.RaisedPetData = XmlUtil.SerializeXml(UpdateDragon(dragon, raisedPetRequest.RaisedPetData, import ?? false));
|
|
ctx.Update(dragon);
|
|
ctx.SaveChanges();
|
|
|
|
// TODO: handle CommonInventoryRequests here too
|
|
|
|
return Ok(new SetRaisedPetResponse {
|
|
RaisedPetSetResult = RaisedPetSetResult.Success
|
|
});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/SetSelectedPet")]
|
|
[VikingSession]
|
|
public IActionResult SetSelectedPet(Viking viking, [FromForm] int raisedPetID) {
|
|
// Find the dragon
|
|
Dragon? dragon = viking.Dragons.FirstOrDefault(e => e.Id == raisedPetID);
|
|
if (dragon is null) {
|
|
return Ok(new SetRaisedPetResponse {
|
|
RaisedPetSetResult = RaisedPetSetResult.Invalid
|
|
});
|
|
}
|
|
|
|
// Set the dragon as selected
|
|
viking.SelectedDragon = dragon;
|
|
ctx.Update(viking);
|
|
ctx.SaveChanges();
|
|
|
|
return Ok(true); // RaisedPetSetResult.Success doesn't work, this does
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/GetAllActivePetsByuserId")]
|
|
[VikingSession(UseLock=false)]
|
|
public RaisedPetData[]? GetAllActivePetsByuserId(Viking viking, [FromForm] string userId, [FromForm] bool active) {
|
|
RaisedPetData[] dragons = viking.Dragons // TODO (multiplayer) we should use userId ?
|
|
.Where(d => d.RaisedPetData is not null)
|
|
.Select(GetRaisedPetDataFromDragon)
|
|
.ToArray();
|
|
|
|
if (dragons.Length == 0) {
|
|
return null;
|
|
}
|
|
return dragons;
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetUnselectedPetByTypes")]
|
|
[VikingSession(UseLock=false)]
|
|
public RaisedPetData[]? GetUnselectedPetByTypes(Viking viking, [FromForm] string petTypeIDs, [FromForm] bool active) {
|
|
RaisedPetData[] dragons = viking.Dragons
|
|
.Where(d => d.RaisedPetData is not null)
|
|
.Select(GetRaisedPetDataFromDragon)
|
|
.ToArray();
|
|
|
|
if (dragons.Length == 0) {
|
|
return null;
|
|
}
|
|
|
|
List<RaisedPetData> filteredDragons = new List<RaisedPetData>();
|
|
int[] petTypeIDsInt = Array.ConvertAll(petTypeIDs.Split(','), s => int.Parse(s));
|
|
foreach (RaisedPetData dragon in dragons) {
|
|
if (petTypeIDsInt.Contains(dragon.PetTypeID)) {
|
|
filteredDragons.Add(dragon);
|
|
}
|
|
}
|
|
|
|
if (filteredDragons.Count == 0) {
|
|
return null;
|
|
}
|
|
|
|
return filteredDragons.ToArray();
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetSelectedRaisedPet")]
|
|
[VikingSession(UseLock=false)]
|
|
public RaisedPetData[]? GetSelectedRaisedPet(Viking viking, [FromForm] string userId, [FromForm] bool isActive) {
|
|
Dragon? dragon = viking.SelectedDragon;
|
|
if (dragon is null) {
|
|
return null;
|
|
}
|
|
|
|
return new RaisedPetData[] {
|
|
GetRaisedPetDataFromDragon(dragon)
|
|
};
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/SetImage")]
|
|
[VikingSession]
|
|
public bool SetImage(Viking viking, [FromForm] string ImageType, [FromForm] int ImageSlot, [FromForm] string contentXML, [FromForm] string imageFile) {
|
|
// TODO: the other properties of contentXML
|
|
ImageData data = XmlUtil.DeserializeXml<ImageData>(contentXML);
|
|
|
|
bool newImage = false;
|
|
Image? image = viking.Images.FirstOrDefault(e => e.ImageType == ImageType && e.ImageSlot == ImageSlot);
|
|
if (image is null) {
|
|
image = new Image {
|
|
ImageType = ImageType,
|
|
ImageSlot = ImageSlot,
|
|
Viking = viking,
|
|
};
|
|
newImage = true;
|
|
}
|
|
|
|
// Save the image in the db
|
|
image.ImageData = imageFile;
|
|
image.TemplateName = data.TemplateName;
|
|
|
|
if (newImage) {
|
|
ctx.Images.Add(image);
|
|
} else {
|
|
ctx.Images.Update(image);
|
|
}
|
|
ctx.SaveChanges();
|
|
|
|
return true;
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetImage")]
|
|
[VikingSession(UseLock=false)]
|
|
public ImageData? GetImage(Viking viking, [FromForm] string ImageType, [FromForm] int ImageSlot) {
|
|
return GetImageData(viking, ImageType, ImageSlot);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetImageByUserId")]
|
|
public ImageData? GetImageByUserId([FromForm] string userId, [FromForm] string ImageType, [FromForm] int ImageSlot) {
|
|
Viking? viking = ctx.Vikings.FirstOrDefault(e => e.Id == userId);
|
|
if (viking is null || viking.Images is null) {
|
|
return null;
|
|
}
|
|
|
|
// TODO: should we restrict images to only those the caller owns?
|
|
|
|
return GetImageData(viking, ImageType, ImageSlot);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/GetUserUpcomingMissionState")]
|
|
public IActionResult GetUserUpcomingMissionState([FromForm] string apiToken, [FromForm] string userId) {
|
|
Viking? viking = ctx.Vikings.FirstOrDefault(x => x.Id == userId);
|
|
if (viking is null)
|
|
return Ok("error");
|
|
|
|
UserMissionStateResult result = new UserMissionStateResult { Missions = new List<Mission>() };
|
|
foreach (var mission in viking.MissionStates.Where(x => x.MissionStatus == MissionStatus.Upcoming))
|
|
result.Missions.Add(missionService.GetMissionWithProgress(mission.MissionId, viking.Id));
|
|
|
|
result.UserID = Guid.Parse(viking.Id);
|
|
return Ok(result);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/GetUserActiveMissionState")]
|
|
public IActionResult GetUserActiveMissionState([FromForm] string apiToken, [FromForm] string userId) {
|
|
Viking? viking = ctx.Vikings.FirstOrDefault(x => x.Id == userId);
|
|
if (viking is null)
|
|
return Ok("error");
|
|
|
|
UserMissionStateResult result = new UserMissionStateResult { Missions = new List<Mission>() };
|
|
foreach (var mission in viking.MissionStates.Where(x => x.MissionStatus == MissionStatus.Active)) {
|
|
Mission updatedMission = missionService.GetMissionWithProgress(mission.MissionId, viking.Id);
|
|
if (mission.UserAccepted != null)
|
|
updatedMission.Accepted = (bool)mission.UserAccepted;
|
|
result.Missions.Add(updatedMission);
|
|
}
|
|
|
|
result.UserID = Guid.Parse(viking.Id);
|
|
return Ok(result);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/GetUserCompletedMissionState")]
|
|
public IActionResult GetUserCompletedMissionState([FromForm] string apiToken, [FromForm] string userId) {
|
|
Viking? viking = ctx.Vikings.FirstOrDefault(x => x.Id == userId);
|
|
if (viking is null)
|
|
return Ok("error");
|
|
|
|
UserMissionStateResult result = new UserMissionStateResult { Missions = new List<Mission>() };
|
|
foreach (var mission in viking.MissionStates.Where(x => x.MissionStatus == MissionStatus.Completed))
|
|
result.Missions.Add(missionService.GetMissionWithProgress(mission.MissionId, viking.Id));
|
|
|
|
result.UserID = Guid.Parse(viking.Id);
|
|
return Ok(result);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/AcceptMission")]
|
|
[VikingSession]
|
|
public IActionResult AcceptMission(Viking viking, [FromForm] string userId, [FromForm] int missionId) {
|
|
if (viking.Id != userId)
|
|
return Unauthorized("Can't accept not owned mission");
|
|
|
|
MissionState? missionState = viking.MissionStates.FirstOrDefault(x => x.MissionId == missionId);
|
|
if (missionState is null || missionState.MissionStatus != MissionStatus.Upcoming)
|
|
return Ok(false);
|
|
|
|
missionState.MissionStatus = MissionStatus.Active;
|
|
missionState.UserAccepted = true;
|
|
ctx.SaveChanges();
|
|
return Ok(true);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/GetUserMissionState")]
|
|
//[VikingSession(UseLock=false)]
|
|
public IActionResult GetUserMissionState([FromForm] string userId, [FromForm] string filter) {
|
|
MissionRequestFilterV2 filterV2 = XmlUtil.DeserializeXml<MissionRequestFilterV2>(filter);
|
|
Viking? viking = ctx.Vikings.FirstOrDefault(x => x.Id == userId);
|
|
if (viking is null)
|
|
return Ok("error");
|
|
|
|
UserMissionStateResult result = new UserMissionStateResult { Missions = new List<Mission>() };
|
|
foreach (var m in filterV2.MissionPair)
|
|
if (m.MissionID != null)
|
|
result.Missions.Add(missionService.GetMissionWithProgress((int)m.MissionID, viking.Id));
|
|
|
|
result.UserID = Guid.Parse(viking.Id);
|
|
return Ok(result);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/SetTaskState")]
|
|
[VikingSession]
|
|
public IActionResult SetTaskState(Viking viking, [FromForm] string userId, [FromForm] int missionId, [FromForm] int taskId, [FromForm] bool completed, [FromForm] string xmlPayload) {
|
|
if (viking.Id != userId)
|
|
return Unauthorized("Can't set not owned task");
|
|
|
|
List<MissionCompletedResult> results = missionService.UpdateTaskProgress(missionId, taskId, userId, completed, xmlPayload);
|
|
|
|
SetTaskStateResult taskResult = new SetTaskStateResult {
|
|
Success = true,
|
|
Status = SetTaskStateStatus.TaskCanBeDone,
|
|
};
|
|
|
|
if (results.Count > 0)
|
|
taskResult.MissionsCompleted = results.ToArray();
|
|
|
|
return Ok(taskResult);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetBuddyList")]
|
|
public IActionResult GetBuddyList() {
|
|
// TODO: this is a placeholder
|
|
return Ok(new BuddyList { Buddy = new Buddy[0] });
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/PurchaseItems")]
|
|
[VikingSession]
|
|
public IActionResult PurchaseItems(Viking viking, [FromForm] string purchaseItemRequest) {
|
|
PurchaseStoreItemRequest request = XmlUtil.DeserializeXml<PurchaseStoreItemRequest>(purchaseItemRequest);
|
|
CommonInventoryResponseItem[] items = new CommonInventoryResponseItem[request.Items.Length];
|
|
for (int i = 0; i < request.Items.Length; i++) {
|
|
items[i] = inventoryService.AddItemToInventoryAndGetResponse(viking, request.Items[i], 1);
|
|
// NOTE: The quantity of purchased items is always 0 and the items are instead duplicated in both the request and the response.
|
|
// Call AddItemToInventoryAndGetResponse with Quantity == 1 we get response with quantity == 0.
|
|
}
|
|
|
|
CommonInventoryResponse response = new CommonInventoryResponse {
|
|
Success = true,
|
|
CommonInventoryIDs = items,
|
|
UserGameCurrency = new UserGameCurrency {
|
|
UserID = Guid.Parse(viking.Id),
|
|
UserGameCurrencyID = 1, // TODO: user's wallet ID?
|
|
CashCurrency = 65536,
|
|
GameCurrency = 65536,
|
|
}
|
|
};
|
|
return Ok(response);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/PurchaseItems")]
|
|
[VikingSession]
|
|
public IActionResult PurchaseItemsV1(Viking viking, [FromForm] string itemIDArrayXml) {
|
|
int[] itemIdArr = XmlUtil.DeserializeXml<int[]>(itemIDArrayXml);
|
|
CommonInventoryResponseItem[] items = new CommonInventoryResponseItem[itemIdArr.Length];
|
|
for (int i = 0; i < itemIdArr.Length; i++) {
|
|
items[i] = inventoryService.AddItemToInventoryAndGetResponse(viking, itemIdArr[i], 1);
|
|
// NOTE: The quantity of purchased items is always 0 and the items are instead duplicated in both the request and the response.
|
|
// Call AddItemToInventoryAndGetResponse with Quantity == 1 we get response with quantity == 0.
|
|
}
|
|
|
|
CommonInventoryResponse response = new CommonInventoryResponse {
|
|
Success = true,
|
|
CommonInventoryIDs = items,
|
|
UserGameCurrency = new UserGameCurrency {
|
|
UserID = Guid.Parse(viking.Id),
|
|
UserGameCurrencyID = 1, // TODO: user's wallet ID?
|
|
CashCurrency = 65536,
|
|
GameCurrency = 65536,
|
|
}
|
|
};
|
|
return Ok(response);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetUserRoomItemPositions")]
|
|
[VikingSession(UseLock=false)]
|
|
public IActionResult GetUserRoomItemPositions(Viking viking, [FromForm] string roomID) {
|
|
if (roomID is null)
|
|
roomID = "";
|
|
Room? room = viking.Rooms.FirstOrDefault(x => x.RoomId == roomID); // TODO: this can break visiting farm of another viking's
|
|
if (room is null)
|
|
return Ok(new UserItemPositionList { UserItemPosition = new UserItemPosition[0] });
|
|
return Ok(roomService.GetUserItemPositionList(room));
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/SetUserRoomItemPositions")]
|
|
[VikingSession]
|
|
public IActionResult SetUserRoomItemPositions(Viking viking, [FromForm] string createXml, [FromForm] string updateXml, [FromForm] string removeXml, [FromForm] string roomID) {
|
|
if (roomID is null)
|
|
roomID = "";
|
|
Room? room = viking.Rooms.FirstOrDefault(x => x.RoomId == roomID);
|
|
if (room is null) {
|
|
room = new Room {
|
|
RoomId = roomID,
|
|
Items = new List<RoomItem>()
|
|
};
|
|
viking.Rooms.Add(room);
|
|
ctx.SaveChanges();
|
|
}
|
|
|
|
UserItemPositionSetRequest[] createItems = XmlUtil.DeserializeXml<UserItemPositionSetRequest[]>(createXml);
|
|
UserItemPositionSetRequest[] updateItems = XmlUtil.DeserializeXml<UserItemPositionSetRequest[]>(updateXml);
|
|
int[] deleteItems = XmlUtil.DeserializeXml<int[]>(removeXml);
|
|
|
|
Tuple<int[], UserItemState[]> createData = roomService.CreateItems(createItems, room);
|
|
UserItemState[] state = roomService.UpdateItems(updateItems, room);
|
|
roomService.DeleteItems(deleteItems, room);
|
|
|
|
UserItemPositionSetResponse response = new UserItemPositionSetResponse {
|
|
Success = true,
|
|
CreatedUserItemPositionIDs = createData.Item1,
|
|
UserItemStates = createData.Item2,
|
|
Result = ItemPositionValidationResult.Valid
|
|
};
|
|
|
|
if (state.Length > 0)
|
|
response.UserItemStates = state;
|
|
|
|
return Ok(response);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetUserRoomList")]
|
|
public IActionResult GetUserRoomList([FromForm] string request) {
|
|
// TODO: Categories are not supported
|
|
UserRoomGetRequest userRoomRequest = XmlUtil.DeserializeXml<UserRoomGetRequest>(request);
|
|
ICollection<Room>? rooms = ctx.Vikings.FirstOrDefault(x => x.Id == userRoomRequest.UserID.ToString())?.Rooms;
|
|
UserRoomResponse response = new UserRoomResponse { UserRoomList = new List<UserRoom>() };
|
|
if (rooms is null)
|
|
return Ok(response);
|
|
foreach (var room in rooms) {
|
|
if (room.RoomId == "MyRoomINT" || room.RoomId == "StaticFarmItems") continue;
|
|
|
|
int itemID = 0;
|
|
if (room.RoomId != "") {
|
|
// farm expansion room: RoomId is Id for expansion item
|
|
if (Int32.TryParse(room.RoomId, out int inventoryItemId)) {
|
|
InventoryItem? item = room.Viking.Inventory.InventoryItems.FirstOrDefault(e => e.Id == inventoryItemId);
|
|
if (item != null) {
|
|
itemID = item.ItemId;
|
|
}
|
|
}
|
|
}
|
|
|
|
UserRoom ur = new UserRoom {
|
|
RoomID = room.RoomId,
|
|
CategoryID = 541, // Placeholder
|
|
CreativePoints = 0, // Placeholder
|
|
ItemID = itemID,
|
|
Name = room.Name
|
|
};
|
|
response.UserRoomList.Add(ur);
|
|
}
|
|
return Ok(response);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/SetUserRoom")]
|
|
[VikingSession]
|
|
public IActionResult SetUserRoom(Viking viking, [FromForm] string request) {
|
|
UserRoom roomRequest = XmlUtil.DeserializeXml<UserRoom>(request);
|
|
Room? room = viking.Rooms.FirstOrDefault(x => x.RoomId == roomRequest.RoomID);
|
|
if (room is null) {
|
|
// setting farm room name can be done before call SetUserRoomItemPositions
|
|
room = new Room {
|
|
RoomId = roomRequest.RoomID,
|
|
Name = roomRequest.Name
|
|
};
|
|
viking.Rooms.Add(room);
|
|
} else {
|
|
room.Name = roomRequest.Name;
|
|
}
|
|
ctx.SaveChanges();
|
|
return Ok(new UserRoomSetResponse {
|
|
Success = true,
|
|
StatusCode = UserRoomValidationResult.Valid
|
|
});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetUserActivityByUserID")]
|
|
public IActionResult GetUserActivityByUserID() {
|
|
// TODO: This is a placeholder
|
|
return Ok(new ArrayOfUserActivity { UserActivity = new UserActivity[0] });
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/SetNextItemState")]
|
|
[VikingSession]
|
|
public IActionResult SetNextItemState(Viking viking, [FromForm] string setNextItemStateRequest) {
|
|
SetNextItemStateRequest request = XmlUtil.DeserializeXml<SetNextItemStateRequest>(setNextItemStateRequest);
|
|
RoomItem? item = ctx.RoomItems.FirstOrDefault(x => x.Id == request.UserItemPositionID);
|
|
if (item is null)
|
|
return Ok();
|
|
|
|
if (item.Room.Viking != viking)
|
|
return Unauthorized("Can't set state not owned item");
|
|
|
|
// NOTE: The game sets OverrideStateCriteria only if a speedup is used
|
|
return Ok(roomService.NextItemState(item, request.OverrideStateCriteria));
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/GetGameData")]
|
|
public IActionResult GetGameData() {
|
|
// TODO: This is a placeholder
|
|
return Ok(new GetGameDataResponse());
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("ContentWebService.asmx/GetUserGameCurrency")]
|
|
public IActionResult GetUserGameCurrency([FromForm] string userId) {
|
|
// TODO: This is a placeholder
|
|
return Ok(new UserGameCurrency {
|
|
CashCurrency = 65536,
|
|
GameCurrency = 65536,
|
|
UserGameCurrencyID = 0,
|
|
UserID = Guid.Parse(userId)
|
|
});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/RerollUserItem")]
|
|
public IActionResult RerollUserItem([FromForm] string apiToken, [FromForm] string request) {
|
|
Viking? viking = ctx.Sessions.FirstOrDefault(e => e.ApiToken == apiToken)?.Viking;
|
|
if (viking is null || viking.Inventory is null) return Unauthorized();
|
|
|
|
RollUserItemRequest req = XmlUtil.DeserializeXml<RollUserItemRequest>(request);
|
|
|
|
// get item
|
|
InventoryItem? invItem = viking.Inventory.InventoryItems.FirstOrDefault(e => e.Id == req.UserInventoryID);
|
|
if (invItem is null)
|
|
return Ok(new RollUserItemResponse { Status = Status.ItemNotFound });
|
|
|
|
// get item data and stats
|
|
ItemData itemData = itemService.GetItem(invItem.ItemId);
|
|
ItemStatsMap itemStatsMap;
|
|
if (invItem.StatsSerialized != null) {
|
|
itemStatsMap = XmlUtil.DeserializeXml<ItemStatsMap>(invItem.StatsSerialized);
|
|
} else {
|
|
itemStatsMap = itemData.ItemStatsMap;
|
|
}
|
|
|
|
List<ItemStat> newStats;
|
|
Status status = Status.Failure;
|
|
|
|
// update stats
|
|
if (req.ItemStatNames != null) {
|
|
// reroll only one stat (from req.ItemStatNames)
|
|
newStats = new List<ItemStat>();
|
|
foreach (string name in req.ItemStatNames) {
|
|
ItemStat itemStat = itemStatsMap.ItemStats.FirstOrDefault(e => e.Name == name);
|
|
|
|
// draw new stats
|
|
StatRangeMap rangeMap = itemData.PossibleStatsMap.Stats.FirstOrDefault(e => e.ItemStatsID == itemStat.ItemStatID).ItemStatsRangeMaps.FirstOrDefault(e => e.ItemTierID == (int)(itemStatsMap.ItemTier));
|
|
int newVal = random.Next(rangeMap.StartRange, rangeMap.EndRange+1);
|
|
|
|
// check draw results
|
|
Int32.TryParse(itemStat.Value, out int oldVal);
|
|
if (newVal > oldVal) {
|
|
itemStat.Value = newVal.ToString();
|
|
newStats.Add(itemStat);
|
|
status = Status.Success;
|
|
}
|
|
}
|
|
// get shards
|
|
inventoryService.AddItemToInventory(viking, InventoryService.Shards, -((int)(itemData.ItemRarity) + (int)(itemStatsMap.ItemTier) - 1));
|
|
} else {
|
|
// reroll full item
|
|
newStats = itemService.CreateItemStats(itemData.PossibleStatsMap, (int)itemData.ItemRarity, (int)itemStatsMap.ItemTier);
|
|
itemStatsMap.ItemStats = newStats.ToArray();
|
|
status = Status.Success;
|
|
// get shards
|
|
int price = 0;
|
|
switch (itemData.ItemRarity) {
|
|
case ItemRarity.Common:
|
|
price = 5;
|
|
break;
|
|
case ItemRarity.Rare:
|
|
price = 7;
|
|
break;
|
|
case ItemRarity.Epic:
|
|
price = 10;
|
|
break;
|
|
case ItemRarity.Legendary:
|
|
price = 20;
|
|
break;
|
|
}
|
|
switch (itemStatsMap.ItemTier) {
|
|
case ItemTier.Tier2:
|
|
price = (int)Math.Floor(price * 1.5);
|
|
break;
|
|
case ItemTier.Tier3:
|
|
case ItemTier.Tier4:
|
|
price = price * 2;
|
|
break;
|
|
}
|
|
inventoryService.AddItemToInventory(viking, InventoryService.Shards, -price);
|
|
}
|
|
|
|
// save
|
|
invItem.StatsSerialized = XmlUtil.SerializeXml(itemStatsMap);
|
|
ctx.SaveChanges();
|
|
|
|
// return results
|
|
return Ok(new RollUserItemResponse {
|
|
Status = status,
|
|
ItemStats = newStats.ToArray() // we need return only updated stats, so can't `= itemStatsMap.ItemStats`
|
|
});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/FuseItems")]
|
|
public IActionResult FuseItems([FromForm] string apiToken, [FromForm] string fuseItemsRequest) {
|
|
Viking? viking = ctx.Sessions.FirstOrDefault(e => e.ApiToken == apiToken)?.Viking;
|
|
if (viking is null || viking.Inventory is null) return Unauthorized();
|
|
|
|
FuseItemsRequest req = XmlUtil.DeserializeXml<FuseItemsRequest>(fuseItemsRequest);
|
|
|
|
ItemData blueprintItem;
|
|
try {
|
|
blueprintItem = itemService.GetItem(req.BluePrintItemID ?? -1);
|
|
} catch(System.Collections.Generic.KeyNotFoundException) {
|
|
return Ok(new FuseItemsResponse { Status = Status.BluePrintItemNotFound });
|
|
}
|
|
|
|
// TODO: check for blueprintItem.BluePrint.Deductibles and blueprintItem.BluePrint.Ingredients
|
|
|
|
// remove items from DeductibleItemInventoryMaps and BluePrintFuseItemMaps
|
|
foreach (var item in req.DeductibleItemInventoryMaps) {
|
|
InventoryItem? invItem = viking.Inventory.InventoryItems.FirstOrDefault(e => e.Id == item.UserInventoryID);
|
|
invItem.Quantity -= item.Quantity;
|
|
}
|
|
foreach (var item in req.BluePrintFuseItemMaps) {
|
|
InventoryItem? invItem = viking.Inventory.InventoryItems.FirstOrDefault(e => e.Id == item.UserInventoryID);
|
|
viking.Inventory.InventoryItems.Remove(invItem);
|
|
}
|
|
|
|
var resItemList = new List<InventoryItemStatsMap>();
|
|
foreach (BluePrintSpecification output in blueprintItem.BluePrint.Outputs) {
|
|
if (output.ItemID is null)
|
|
continue;
|
|
|
|
// get new item info
|
|
int newItemId = (int)(output.ItemID);
|
|
ItemData newItemData = itemService.GetItem(newItemId);
|
|
|
|
// check for "box tickets"
|
|
if (itemService.ItemHasCategory(newItemData, 462)) {
|
|
newItemId = itemService.OpenBox(newItemData).ItemId;
|
|
}
|
|
|
|
resItemList.Add(
|
|
inventoryService.AddBattleItemToInventory(viking, newItemId, (int)output.Tier)
|
|
);
|
|
}
|
|
|
|
// return response with new item info
|
|
return Ok(new FuseItemsResponse {
|
|
Status = Status.Success,
|
|
InventoryItemStatsMaps = resItemList
|
|
});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/SellItems")]
|
|
public IActionResult SellItems([FromForm] string apiToken, [FromForm] string sellItemsRequest) {
|
|
Viking? viking = ctx.Sessions.FirstOrDefault(e => e.ApiToken == apiToken)?.Viking;
|
|
if (viking is null || viking.Inventory is null) return Unauthorized();
|
|
|
|
int price = 0;
|
|
SellItemsRequest req = XmlUtil.DeserializeXml<SellItemsRequest>(sellItemsRequest);
|
|
foreach (var invItemID in req.UserInventoryCommonIDs) {
|
|
// get item from inventory
|
|
InventoryItem? item = viking.Inventory.InventoryItems.FirstOrDefault(e => e.Id == invItemID);
|
|
|
|
// get item data
|
|
ItemData? itemData = itemService.GetItem(item.ItemId);
|
|
|
|
// calculate price
|
|
switch (itemData.ItemRarity) {
|
|
case ItemRarity.Common:
|
|
price += 1;
|
|
break;
|
|
case ItemRarity.Rare:
|
|
price += 3;
|
|
break;
|
|
case ItemRarity.Epic:
|
|
price += 5;
|
|
break;
|
|
case ItemRarity.Legendary:
|
|
price += 10;
|
|
break;
|
|
}
|
|
|
|
// TODO: cash rewards
|
|
|
|
// remove item
|
|
viking.Inventory.InventoryItems.Remove(item);
|
|
}
|
|
|
|
// apply shards reward
|
|
CommonInventoryResponseItem? resShardsItem = inventoryService.AddItemToInventoryAndGetResponse(viking, InventoryService.Shards, price);
|
|
|
|
// save
|
|
ctx.SaveChanges();
|
|
|
|
// return success with shards reward
|
|
return Ok(new CommonInventoryResponse {
|
|
Success = true,
|
|
CommonInventoryIDs = new CommonInventoryResponseItem[] {
|
|
resShardsItem
|
|
}
|
|
});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/AddBattleItems")]
|
|
public IActionResult AddBattleItems([FromForm] string apiToken, [FromForm] string request) {
|
|
Viking? viking = ctx.Sessions.FirstOrDefault(e => e.ApiToken == apiToken)?.Viking;
|
|
if (viking is null || viking.Inventory is null) return Unauthorized();
|
|
|
|
AddBattleItemsRequest req = XmlUtil.DeserializeXml<AddBattleItemsRequest>(request);
|
|
|
|
var resItemList = new List<InventoryItemStatsMap>();
|
|
foreach (BattleItemTierMap battleItemTierMap in req.BattleItemTierMaps) {
|
|
for (int i=0; i<battleItemTierMap.Quantity; ++i) {
|
|
resItemList.Add(
|
|
inventoryService.AddBattleItemToInventory(viking, battleItemTierMap.ItemID, (int)battleItemTierMap.Tier, battleItemTierMap.ItemStats)
|
|
// NOTE: battleItemTierMap.ItemStats is extension for importer
|
|
);
|
|
}
|
|
}
|
|
|
|
return Ok(new AddBattleItemsResponse{
|
|
Status = Status.Success,
|
|
InventoryItemStatsMaps = resItemList
|
|
});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Produces("application/xml")]
|
|
[Route("V2/ContentWebService.asmx/ApplyRewards")]
|
|
public IActionResult ApplyRewards([FromForm] string apiToken, [FromForm] string request) {
|
|
Viking? viking = ctx.Sessions.FirstOrDefault(e => e.ApiToken == apiToken)?.Viking;
|
|
if (viking is null || viking.Inventory is null) return Unauthorized();
|
|
|
|
ApplyRewardsRequest req = XmlUtil.DeserializeXml<ApplyRewardsRequest>(request);
|
|
|
|
List<AchievementReward> achievementRewards = new List<AchievementReward>();
|
|
UserItemStatsMap rewardedItem = null;
|
|
CommonInventoryResponse rewardedBlueprint = null;
|
|
|
|
int rewardMultipler = 0;
|
|
if (req.LevelRewardType == LevelRewardType.LevelFailure) {
|
|
rewardMultipler = 1;
|
|
} else if (req.LevelRewardType == LevelRewardType.LevelCompletion) {
|
|
rewardMultipler = 2 * req.LevelDifficultyID;
|
|
}
|
|
|
|
if (rewardMultipler > 0) {
|
|
// TODO: XP values and method of calculation is not grounded in anything ...
|
|
|
|
// dragons XP
|
|
int dragonXp = 40 * rewardMultipler;
|
|
foreach (RaisedPetEntityMap petInfo in req.RaisedPetEntityMaps) {
|
|
Dragon? dragon = viking.Dragons.FirstOrDefault(e => e.Id == petInfo.RaisedPetID);
|
|
dragon.PetXP = (dragon.PetXP ?? 0) + dragonXp;
|
|
achievementRewards.Add(new AchievementReward{
|
|
EntityID = petInfo.EntityID,
|
|
PointTypeID = AchievementPointTypes.DragonXP,
|
|
EntityTypeID = 3, // dragon ?
|
|
RewardID = 1265, // TODO: placeholder
|
|
Amount = dragonXp
|
|
});
|
|
}
|
|
|
|
// player XP and gems
|
|
achievementRewards.Add(
|
|
achievementService.AddAchievementPointsAndGetReward(viking, AchievementPointTypes.PlayerXP, 60 * rewardMultipler)
|
|
);
|
|
achievementRewards.Add(
|
|
achievementService.AddAchievementPointsAndGetReward(viking, AchievementPointTypes.CashCurrency, 2 * rewardMultipler)
|
|
);
|
|
}
|
|
|
|
// - battle backpack items and blueprints
|
|
if (req.LevelRewardType != LevelRewardType.LevelFailure) {
|
|
ItemData rewardItem = itemService.GetDTReward();
|
|
if (itemService.ItemHasCategory(rewardItem, 651)) {
|
|
// blueprint
|
|
CommonInventoryResponseItem blueprintItem = inventoryService.AddItemToInventoryAndGetResponse(viking, rewardItem.ItemID, 1);
|
|
rewardedBlueprint = new CommonInventoryResponse {
|
|
Success = true,
|
|
CommonInventoryIDs = new CommonInventoryResponseItem[] {
|
|
blueprintItem
|
|
}
|
|
};
|
|
} else {
|
|
// DT item
|
|
InventoryItemStatsMap item = inventoryService.AddBattleItemToInventory(viking, rewardItem.ItemID, random.Next(1, 4));
|
|
rewardedItem = new UserItemStatsMap {
|
|
Item = item.Item,
|
|
ItemStats = item.ItemStatsMap.ItemStats,
|
|
ItemTier = item.ItemStatsMap.ItemTier,
|
|
CreatedDate = new DateTime(DateTime.Now.Ticks)
|
|
};
|
|
}
|
|
}
|
|
|
|
// save
|
|
ctx.SaveChanges();
|
|
|
|
return Ok(new ApplyRewardsResponse {
|
|
Status = Status.Success,
|
|
AchievementRewards = achievementRewards.ToArray(),
|
|
RewardedItemStatsMap = rewardedItem,
|
|
CommonInventoryResponse = rewardedBlueprint,
|
|
});
|
|
}
|
|
|
|
private RaisedPetData GetRaisedPetDataFromDragon (Dragon dragon) {
|
|
RaisedPetData data = XmlUtil.DeserializeXml<RaisedPetData>(dragon.RaisedPetData);
|
|
data.RaisedPetID = dragon.Id;
|
|
data.EntityID = Guid.Parse(dragon.EntityId);
|
|
data.IsSelected = (dragon.Viking.SelectedDragonId == dragon.Id);
|
|
return data;
|
|
}
|
|
|
|
// Needs to merge newDragonData into dragonData
|
|
private RaisedPetData UpdateDragon (Dragon dragon, RaisedPetData newDragonData, bool import = false) {
|
|
RaisedPetData dragonData = XmlUtil.DeserializeXml<RaisedPetData>(dragon.RaisedPetData);
|
|
|
|
// The simple attributes
|
|
dragonData.IsPetCreated = newDragonData.IsPetCreated;
|
|
if (newDragonData.ValidationMessage is not null) dragonData.ValidationMessage = newDragonData.ValidationMessage;
|
|
if (newDragonData.EntityID is not null) dragonData.EntityID = newDragonData.EntityID;
|
|
if (newDragonData.Name is not null) dragonData.Name = newDragonData.Name;
|
|
dragonData.PetTypeID = newDragonData.PetTypeID;
|
|
if (newDragonData.GrowthState is not null) {
|
|
achievementService.DragonLevelUpOnAgeUp(dragon, dragonData.GrowthState, newDragonData.GrowthState);
|
|
dragonData.GrowthState = newDragonData.GrowthState;
|
|
}
|
|
if (newDragonData.ImagePosition is not null) dragonData.ImagePosition = newDragonData.ImagePosition;
|
|
if (newDragonData.Geometry is not null) dragonData.Geometry = newDragonData.Geometry;
|
|
if (newDragonData.Texture is not null) dragonData.Texture = newDragonData.Texture;
|
|
dragonData.Gender = newDragonData.Gender;
|
|
if (newDragonData.Accessories is not null) dragonData.Accessories = newDragonData.Accessories;
|
|
if (newDragonData.Colors is not null) dragonData.Colors = newDragonData.Colors;
|
|
if (newDragonData.Skills is not null) dragonData.Skills = newDragonData.Skills;
|
|
if (newDragonData.States is not null) dragonData.States = newDragonData.States;
|
|
|
|
dragonData.IsSelected = newDragonData.IsSelected;
|
|
dragonData.IsReleased = newDragonData.IsReleased;
|
|
dragonData.UpdateDate = newDragonData.UpdateDate;
|
|
|
|
if (import) dragonData.CreateDate = newDragonData.CreateDate;
|
|
|
|
// Attributes is special - the entire list isn't re-sent, so we need to manually update each
|
|
if (dragonData.Attributes is null) dragonData.Attributes = new RaisedPetAttribute[] { };
|
|
List<RaisedPetAttribute> attribs = dragonData.Attributes.ToList();
|
|
if (newDragonData.Attributes is not null) {
|
|
foreach (RaisedPetAttribute newAttribute in newDragonData.Attributes) {
|
|
RaisedPetAttribute? attribute = attribs.Find(a => a.Key == newAttribute.Key);
|
|
if (attribute is null) {
|
|
attribs.Add(newAttribute);
|
|
}
|
|
else {
|
|
attribute.Value = newAttribute.Value;
|
|
attribute.Type = newAttribute.Type;
|
|
}
|
|
}
|
|
dragonData.Attributes = attribs.ToArray();
|
|
}
|
|
|
|
return dragonData;
|
|
}
|
|
|
|
private ImageData? GetImageData (Viking viking, String ImageType, int ImageSlot) {
|
|
Image? image = viking.Images.FirstOrDefault(e => e.ImageType == ImageType && e.ImageSlot == ImageSlot);
|
|
if (image is null) {
|
|
return null;
|
|
}
|
|
|
|
string imageUrl = string.Format("{0}://{1}/RawImage/{2}/{3}/{4}.jpg", HttpContext.Request.Scheme, HttpContext.Request.Host, viking.Id, ImageType, ImageSlot);
|
|
|
|
return new ImageData {
|
|
ImageURL = imageUrl,
|
|
TemplateName = image.TemplateName,
|
|
};
|
|
}
|
|
|
|
private void AddSuggestion(Random rand, string name, List<string> suggestions) {
|
|
if (ctx.Vikings.Any(x => x.Name == name) || suggestions.Contains(name)) {
|
|
name += rand.Next(1, 5000);
|
|
if (ctx.Vikings.Any(x => x.Name == name) || suggestions.Contains(name)) return;
|
|
}
|
|
suggestions.Add(name);
|
|
}
|
|
|
|
private string GetNameSuggestion(Random rand, string username, string[] adjectives) {
|
|
string name = username;
|
|
if (rand.NextDouble() >= 0.5)
|
|
name = username + "The" + adjectives[rand.Next(adjectives.Length)];
|
|
if (name == username || rand.NextDouble() >= 0.5)
|
|
return adjectives[rand.Next(adjectives.Length)] + name;
|
|
return name;
|
|
}
|
|
}
|