public override IEnumerable <XPage> GetPages(XAlbum album)
{
var folderPath = this.GetAlbumFolderPath(album.ID);
var albumHtml = "";
var albumHtmlFilePath = Path.Combine(this.SourceFolderPath, album.ID + ".html");
var hasNew = album.HasNewModify;
if (hasNew == true)
{
album.Date = album.NewDate;
SaveXTarget();
albumHtml = BaseTarget.SaveAndReturn(album.URL, albumHtmlFilePath, this.Encoding);
}
else
{
albumHtml = File.ReadAllText(albumHtmlFilePath, Encoding.UTF8);
}
//var match = this.GetRegexResult("<b>\\d+?</b>/<b>(?<MaxPage>\\d+?)</b>\\s*?每页\\s*?<b>(?<PageEpisodes>\\d+?)</b>\\s*?共\\s*?<b>(?<EpisodeCount>\\d+?)</b>", albumHtml);
var matches = BaseTarget.GetRegexResults("<a\\shref=\"(?<URL>[0-9a-zA-Z\\._]+?)\">.*?\\[(?<Index>\\d+?)\\].*?</a>", albumHtml);
foreach (var match in matches)
{
yield return(new XPage(album.ID, int.Parse(match.Groups["Index"].Value), new Uri(this.CurrentXTarget.URL, match.Groups["URL"].Value)));
}
}
private void Update()
{
if (isSpawnings)
{
spawnTimer += Time.deltaTime;
if (spawnTimer >= spawnTime)
{
//Reset timer and Spawns
SetNewTime();
spawnTimer = 0.0f;
spawnAmountLeft--;
//Spawn new target and will add any delegates the target might neeed to function in a certain game mode
GameObject targetGO = Spawn(transform.position, transform.rotation);
BaseTarget target = targetGO.GetComponent <BaseTarget>();
if (target != null && onTargetDestroyedSubscriber != null)
{
target.TargetDestroyedSubscriber += onTargetDestroyedSubscriber;
}
}
//Called once we spawn the desired amount
if (spawnAmountLeft <= 0)
{
isSpawnings = false;
}
}
}
//TODO: actually finish this up.
public override void loadLevel(BaseLevelData data, GameController game)
{
if (data.getLevelDataType() != WeightedListLevelData.LEVEL_DATA_TYPE)
{
Debug.Log("Error: Invalid level data for this loader.");
return;
}
WeightedListLevelData levelData = data as WeightedListLevelData;
WeightedList <BaseTargetFactory> _factoryList = levelData.getFactoryList();
//Load the level into the game.
for (int i = 0; i < levelData.getDifficulty(); i++)
{
float targetX = UnityEngine.Random.Range(X_MIN, X_MAX);
float targetY = UnityEngine.Random.Range(Y_MIN, Y_MAX);
float targetSize = UnityEngine.Random.Range(TARGET_MIN, TARGET_MAX);
BaseTargetFactory factory = _factoryList.getItem();
BaseTarget target = factory.makeTarget();
game.addTarget(target, targetX, targetY, targetSize);
}
game.setTime(levelData.getTime(), true);
}
//Adds targets into the game
public bool AddTarget(BaseTarget t)
{
if (sTargets[0] == null)
{
t.mTargetIndex = DTileMap.TileType.Target1;
sTargets[0] = t;
Debug.Log("SpawnTarget at 1: " + sTargetsAlive);
return(true);
}
else if (sTargets[1] == null)
{
t.mTargetIndex = DTileMap.TileType.Target2;
sTargets[1] = t;
Debug.Log("SpawnTarget at 2: " + sTargetsAlive);
return(true);
}
else if (sTargets[2] == null)
{
t.mTargetIndex = DTileMap.TileType.Target3;
sTargets[2] = t;
Debug.Log("SpawnTarget at 3: " + sTargetsAlive);
return(true);
}
return(true);
}
void Update()
{
if (_gameActive == true)
{
//Update Time
_time -= Time.deltaTime;
updateTimerBar();
if (_time <= 0)
{
endGame();
return;
}
//Check for touches, only new touches count.
foreach (Touch touch in Input.touches)
{
if (touch.phase == TouchPhase.Began)
{
//Determine what the touch is touching.
RaycastHit2D hitInfo = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero);
if (hitInfo.collider != null)
{
Debug.Log("Object Hit : " + hitInfo.collider.gameObject.name);
BaseTarget targetComp = hitInfo.collider.gameObject.GetComponent <BaseTarget>();
if (targetComp != null)
{
targetComp.onClick(this);
}
}
}
}
}
}
public UITarget assignTarget(BaseTarget target)
{
_target = target;
if (GetComponentInChildren <Text>() != null)
{
GetComponentInChildren <Text>().text = target.name;
}
return(this);
}
public RecognizeEpisodeWizardWindow(BaseTarget target, XEpisode episode)
{
this.ViewModel = new RecognizeEpisodeViewModel(target, episode, this)
{
RecognizeStateChanged = (st) => { SetCurrentPage(st); },
};
InitializeComponent();
}
//When the cannonball collides and tries to find if the other Collider has a target script.
//if it does the target will take damage.
private void OnTargetCollision(Collision collTarget)
{
BaseTarget target = collTarget.gameObject.GetComponent <BaseTarget>();
if (target != null)
{
target.TakeDamage(damage);
Destroy(gameObject);
}
}
public void SetTarget()
{
int index = UnityEngine.Random.Range(0, targets.Count);
activeTarget = targets[index];
activeTarget.gameObject.SetActive(true);
targets.Except(new[] { targets[index] }).ToList().ForEach(t => t.gameObject.SetActive(false));
hauler.UpdateTarget(activeTarget);
}
void OnAllKnifesShoot(EventData eventData)
{
++currTarget;
//Call cool destroy animation
Destroy(currTargetGameObject.gameObject);
currTargetGameObject = null;
//Call after animation
LeanTween.delayedCall(UIConsts.menuAnimationsTime, () => {
SpawnTarget();
});
}
public EpisodeDownloadWindowViewModel(BaseTarget target, Window win)
{
this.CurrentWindow = win;
this.CurrentTarget = target;
this.InitCommands();
this.CurrentWindow.Closing += CurrentWindow_Closing;
this.Receive(this.CurrentTarget.GetAlbums());
this.DownloadInfoCollection = new ObservableCollection <EpisodeContentDownloadInfo>();
}
public void RemoveTarget(BaseTarget target)
{
if (_targets.Contains(target))
{
_targets.Remove(target);
Destroy(target.gameObject);
target = null;
}
if (_targets.Count == 0)
{
Debug.Log("You Win!");
endGame();
}
}
void SpawnTarget()
{
if (currTarget < TargetPrefabs.Length)
{
currTargetGameObject = Instantiate(TargetPrefabs[currTarget], transform).GetComponent <BaseTarget>();
}
else
{
currTargetGameObject = Instantiate(TargetPrefabs[Random.Range(0, TargetPrefabs.Length)], transform).GetComponent <BaseTarget>();
}
EventData eventData = new EventData("OnNewTarget");
eventData["maxShoots"] = currTargetGameObject.NeededShoots;
GameManager.Instance.EventManager.CallOnNewTarget(eventData);
}
public void RemoveTarget(BaseTarget targetToRemove)
{
DTileMap.TileType temp = targetToRemove.mTargetIndex;
if (temp == DTileMap.TileType.Target1)
{
sTargets[0] = null;
}
else if (temp == DTileMap.TileType.Target2)
{
sTargets[1] = null;
}
else if (temp == DTileMap.TileType.Target3)
{
sTargets[2] = null;
}
sTargetsAlive--;
}
public void addTarget(BaseTarget target, float targetX, float targetY, float targetScale)
{
if (_targets.Contains(target))
{
return;
}
_targets.Add(target);
SpriteRenderer renderer = target.GetComponent <SpriteRenderer>();
if (renderer != null)
{
renderer.sortingLayerName = "targets";
renderer.sortingOrder = _targets.Count;
}
target.setTargetLayerOrder(_targets.Count);
target.transform.parent = gameObject.transform;
target.transform.localScale = new Vector3(targetScale, targetScale);
target.transform.localPosition = new Vector3(targetX, targetY, -(_targets.Count * 0.01f)); //The z hack fixes an issue with which target is touched detection.
target.onAddedToGame(this);
}
public RecognizeEpisodeViewModel(BaseTarget target, XEpisode episode, Window view)
{
this.Target = target;
this.Episode = episode;
this.Window = view;
this.Window.Closing += Window_Closing;
this.Window.DataContext = this;
this.AudioPlayer = new MediaAudioPlayer();
this.AudioPlayer.Load(this.LocalEpisode.AudioFilePath);
BuildWorkflowApp();
if (this.Window.IsLoaded == true)
{
Init();
}
else
{
this.Window.Loaded += ParentWindow_Loaded;
}
}
protected void OnDisable()
{
_target = null;
button.interactable = false;
}
public override IEnumerable <XEpisode> GetEpisodes(XPage page)
{
DateTime newDT = DateTime.MinValue;
var html = BaseTarget.SaveAndReturn(page.URL,
Path.Combine(this.GetAlbumFolderPath(page.AlbumID), page.Index.ToString() + ".html"),
this.Encoding);
HtmlDocument htmlDoc = new HtmlDocument();
htmlDoc.LoadHtml(html);
var listNode = htmlDoc.GetElementbyId("list");
if (listNode == null)
{
listNode = htmlDoc.DocumentNode.SelectSingleNode(@"//div[@class='list']");
}
if (listNode != null)
{
var liCollection = listNode.SelectNodes("ul/li");
foreach (HtmlNode li in liCollection)
{
//process episode title,date,contentUrl
var a = li.Element("a");
var episodeUrl = new Uri(this.CurrentXTarget.URL, a.Attributes["href"].Value);
var id = Path.GetFileNameWithoutExtension(episodeUrl.ToString());
#region Find and Check Date
DateTime date = DateTime.MinValue;
var match = GetRegexResult("\\d+-\\d+-\\d+", li.InnerHtml);
var dateString = match.Value.Trim();
var array = dateString.Split('-');
int year = int.Parse(array[0]);
int month = int.Parse(array[1]);
int day = int.Parse(array[2]);
if (year < 2000)
{
year += 2000;
}
//Only Return Episodes these after 2012
if (year < FromYear)
{
break;
}
if (VOAUtilities.ChackEpisodeDate(page.AlbumID, year, month, day, out date) == true)
{
date = new DateTime(year, month, day);
}
else
{
date = new DateTime(year, month, day);
}
#endregion
var newEpisode = new XEpisode(page.AlbumID, id, a.InnerText.Trim(), episodeUrl)
{
Date = date
};
//process hasLrc,hasTranslation
var images = li.Elements("img");
foreach (HtmlNode image in images)
{
var imgText = image.Attributes["src"].Value;
if (imgText.Contains("lrc.gif") == true)
{
newEpisode.HasLrc = true;
}
if (imgText.Contains("yi.gif") == true)
{
newEpisode.HasTranslation = true;
}
}
newEpisode = this.CheckEpisode(newEpisode);
yield return(newEpisode);
}
}
}
public Target2(BaseTarget parent = null)
: base(parent)
{
}
public BaseTarget(BaseTarget parent = null)
{
this.SetParent(parent);
ChildrenBinders = new DependencyObjectCollection <DependencyObject>(this);
}
public IndividualTargetResponse UpdateTarget(BaseTarget target)
{
var body = new { target };
return(GenericPut <IndividualTargetResponse>($"targets/{target.Id}.json", body));
}
public IndividualTargetResponse UpdateTarget(BaseTarget target)
{
var body = new { target };
return(GenericPut <IndividualTargetResponse>(string.Format("targets/{0}.json", target.Id), body));
}
public IndividualTargetResponse CreateTarget(BaseTarget target)
{
var body = new { target };
return(GenericPost <IndividualTargetResponse>("targets.json", body));
}
//Adds targets into the game
static public bool AddTarget(BaseTarget t)
{
Targets.Add(t);
TargetsAlive++;
return(true);
}
public async Task <IndividualTargetResponse> UpdateTargetAsync(BaseTarget target)
{
var body = new { target };
return(await GenericPutAsync <IndividualTargetResponse>($"targets/{target.Id}.json", body));
}
public async Task <IndividualTargetResponse> CreateTargetAsync(BaseTarget target)
{
var body = new { target };
return(await GenericPostAsync <IndividualTargetResponse>("targets.json", body));
}
public BaseTarget(BaseTarget parent = null)
{
this.SetParent(parent);
}
public async Task <IndividualTargetResponse> UpdateTargetAsync(BaseTarget target)
{
var body = new { target };
return(await GenericPutAsync <IndividualTargetResponse>(string.Format("targets/{0}.json", target.Id), body));
}
void UpdateAttack()
{
if (mManager.HudUpdated)
{
Debug.Log("Attack" + mManager.HudUpdated);
DTileMap.TileType AttackingTarget = mManager.curDefending;
if (AttackingTarget >= DTileMap.TileType.Target1)
{
BaseTarget targetDefending = mManager.CurrentTargetDefender();
if (mManager.AttackWorked)
{
Debug.Log("Target Die");
mInfamy += targetDefending.mInfamy;
targetDefending.UpdateDie();
}
else
{
Debug.Log("Both Live");
targetDefending.mState = BaseTarget.State.Run;
}
}
else
{
Player playerDefending = mManager.CurrentPlayerDefender();
if (mManager.AttackWorked)
{
Debug.Log("Attack Worked");
Debug.Log("you die");
if (playerDefending.mInfamy > mInfamy)
{
mInfamy++;
playerDefending.mInfamy--;
}
playerDefending.mAlive = false;
playerDefending.gameObject.renderer.enabled = false;
int positionX = playerDefending.mPositionX;
int positionY = playerDefending.mPositionY;
mTileMap.MapInfo.SetTileType(positionX, positionY, DTileMap.TileType.Floor, true);
}
else if (mManager.CounterAttackWorked)
{
Debug.Log("Counter Attack Worked");
Debug.Log("I die");
if (playerDefending.mInfamy < mInfamy)
{
mInfamy--;
playerDefending.mInfamy++;
}
gameObject.renderer.enabled = false;
mTileMap.MapInfo.SetTileType(mPositionX, mPositionY, DTileMap.TileType.Floor, true);
}
else
{
Debug.Log("Both Live");
}
}
if (mManager.HudUpdated)
{
mPlayerPhase = PlayerPhase.End;
}
}
}
public static FieldValueInformation Create(BaseDataFieldModel field, IEnumerable <char> specialChars)
{
var value = FieldValueInformation.Default;
var unformattedValue = string.Empty;
var specialCharsList = new List <char>();
if (specialChars != null)
{
specialCharsList = specialChars.ToList();
}
if (field.Value.Show == YesNo.No)
{
return(value);
}
StyleModel style;
var found = field.Value.TryGetStyle(out style);
if (!found)
{
// Mensaje de Log usando default style;
style = StyleModel.Default;
}
value.Style = style;
if (field.DataSource == null)
{
return(value);
}
var fieldType = field.FieldType;
switch (fieldType)
{
#region Field: Data
case KnownFieldType.Field:
{
var current = (DataFieldModel)field;
var parsedName = BaseTarget.Parse(current.Name, specialCharsList);
var fieldAsAttribute = field.DataSource.Attribute(parsedName);
if (fieldAsAttribute != null)
{
unformattedValue = fieldAsAttribute.Value;
}
}
break;
#endregion
#region Field: Fixed
case KnownFieldType.Fixed:
{
var current = (FixedFieldModel)field;
var @fixed = field.Owner.Parent.Parent.Resources.Fixed;
var fixedItem = @fixed[current.Pieces];
fixedItem.DataSource = field.DataSource;
var parsedName = BaseTarget.Parse(current.Piece, specialCharsList);
var piece = fixedItem.Pieces[parsedName];
unformattedValue = piece.GetValue();
}
break;
#endregion
#region Field: Group
case KnownFieldType.Group:
{
var current = (GroupFieldModel)field;
var currentName = current.Name;
var @fixed = field.Owner.Parent.Parent.Owner.Resources.Fixed;
var groups = field.Owner.Parent.Parent.Owner.Resources.Groups;
var groupValue = string.Empty;
var builder = new StringBuilder();
var group = groups[currentName];
var groupFields = group.Fields;
foreach (var groupField in groupFields)
{
var parsedName = BaseTarget.Parse(groupField.Name, specialCharsList);
var asAttribute = field.DataSource.Attribute(parsedName);
if (asAttribute == null)
{
foreach (var fixedwidth in @fixed)
{
fixedwidth.DataSource = field.DataSource;
var piece = fixedwidth.Pieces[groupField.Name];
if (piece == null)
{
continue;
}
groupValue = piece.GetValue();
}
}
else
{
groupValue = asAttribute.Value;
}
builder.Append(groupValue);
builder.Append(GroupFieldModel.GetSeparatorChar(groupField.Separator));
}
unformattedValue = builder.ToString();
}
break;
#endregion
#region Field: Packet
case KnownFieldType.Packet:
{
var current = (PacketFieldModel)field;
var parsedName = BaseTarget.Parse(current.Name, specialCharsList);
var fieldAsAttribute = field.DataSource.Attribute(parsedName);
if (fieldAsAttribute != null)
{
var builder = new StringBuilder();
builder.Clear();
var inputFormat = current.InputFormat;
var fieldvalue = fieldAsAttribute.Value;
switch (inputFormat)
{
#region InputFormat: FullDateFormat
case KnownInputPacketFormat.FullDateFormat:
if (!string.IsNullOrEmpty(fieldvalue) &&
!fieldvalue.IsNullOrWhiteSpace() &&
!fieldvalue.Trim().Equals("0"))
{
var adjustedValue = string.Concat(new string('0', 14), fieldvalue);
adjustedValue = adjustedValue.Substring(adjustedValue.Length - 14, 14);
builder.Append(adjustedValue.Substring(6, 2));
builder.Append('/');
builder.Append(adjustedValue.Substring(4, 2));
builder.Append('/');
builder.Append(adjustedValue.Substring(0, 4));
builder.Append(' ');
builder.Append(adjustedValue.Substring(8, 2));
builder.Append(':');
builder.Append(adjustedValue.Substring(10, 2));
builder.Append(':');
builder.Append(adjustedValue.Substring(12, 2));
}
break;
#endregion
#region InputFormat: LongDateFormat
case KnownInputPacketFormat.LongDateFormat:
if (!string.IsNullOrEmpty(fieldvalue) &&
!fieldvalue.IsNullOrWhiteSpace() &&
!fieldvalue.Trim().Equals("0"))
{
var adjustedValue = string.Concat(new string('0', 8), fieldvalue);
adjustedValue = adjustedValue.Substring(adjustedValue.Length - 8, 8);
builder.Append(adjustedValue.Substring(0, 4));
builder.Append('/');
builder.Append(adjustedValue.Substring(4, 2));
builder.Append('/');
builder.Append(adjustedValue.Substring(6, 2));
}
break;
#endregion
#region InputFormat: ShortDateFormat
case KnownInputPacketFormat.ShortDateFormat:
if (!string.IsNullOrEmpty(fieldvalue) &&
!fieldvalue.IsNullOrWhiteSpace() &&
!fieldvalue.Trim().Equals("0"))
{
var adjustedValue = string.Concat(new string('0', 6), fieldvalue);
adjustedValue = adjustedValue.Substring(adjustedValue.Length - 6, 6);
builder.Append(adjustedValue.Substring(0, 2));
builder.Append('/');
builder.Append(adjustedValue.Substring(2, 2));
builder.Append('/');
builder.Append(adjustedValue.Substring(4, 2));
}
break;
#endregion
}
unformattedValue = builder.ToString();
}
}
break;
#endregion
}
return(style.Content.DataType.GetFormattedDataValue(unformattedValue));
}
