static IEnumerable <Bar> loadBars(IEnumerable <Glyph> glyphs)
{
State state = new Model.State();
int expectBarNumber = 0;
Bar bar = null;
foreach (Glyph glyph in glyphs)
{
//bool isState = state.Add(note);
// add to the persistent state
glyph.setState(state);
if (glyph.newBarNumber != null)
{
BarNumber barNumber = glyph.newBarNumber;
// new Bar
assert(barNumber.number == ++expectBarNumber);
if (bar != null)
{
yield return(bar);
}
bar = new Bar(barNumber, state.Clone());
continue;
}
if (bar != null)
{
glyph.setBar(bar);
}
}
yield return(bar);
}
private void UpdateStatus(Model.State state, string s)
{
if (state == Model.State.StateIdle)
{
_busyForm.Invoke(new Action(() =>
{
_busyForm.Hide();
_busyForm.UpdateLabel("Busy");
}));
return;
}
if (_busyForm != null)
{
if (_busyForm.InvokeRequired)
{
_busyForm.Invoke(new Action(() =>
{
_busyForm.UpdateLabel(s);
}));
}
else
{
_busyForm.UpdateLabel(s);
}
}
}
private void reserveBtn_Click(object sender, EventArgs e)
{
try
{
Model.Item item = controller.GetItem(int.Parse(itemIdTB.Text.Trim()));
if (item == null)
{
updateMsg("The requested item does not exist.", true);
return;
}
Model.Borrower borrower = controller.GetBorrower(int.Parse(borrowerIdTB.Text.Trim()));
if (borrower == null)
{
updateMsg(string.Format("A customer with the id {0}\r\ndoes not exist.", borrowerIdTB.Text), true);
return;
}
Model.State itemState = item.State;
if (itemState == Model.State.Available)
{
updateMsg("The requested item is currently available.", true);
}
else
{
controller.Reserve(borrower.Id, item.ItemId);
updateMsg("Reserved successfully.", false);
}
}
catch (FormatException ex)
{
Console.WriteLine(ex.StackTrace);
updateMsg("Invalid input format.", true);
}
}
public void move(BoardController board, bool movePlayer1)
{
Model.State state = getState(board, movePlayer1);
if (state.isTerminal)
{
Debug.Log("AI Not moving; game is over!");
return;
}
Model.Action act = strat.getAction(state);
PieceController mover = getPiece(board, act);
PieceController captured = board.getTile(act.newPos).myPiece;
if (captured != null)
{
Debug.Log("AI Moving player " + mover.model.playerNum + "'s " + mover.model.color + " piece at (" + mover.model.position.x + "," + mover.model.position.y + ") "
+ " to capture player " + captured.model.playerNum + "'s " + captured.model.color + " piece at (" + captured.model.position.x + "," + captured.model.position.y + ").");
board.combine(mover, captured);
}
else
{
Debug.Log("AI Moving player " + mover.model.playerNum + "'s " + mover.model.color + " piece at (" + mover.model.position.x + "," + mover.model.position.y + ") "
+ " to (" + act.newPos.x + "," + act.newPos.y + ").");
mover.move(act.newPos);
}
}
public Address(string streetNumber, string streetName, string suburb, State state, string postCode)
{
StreetNumber = streetNumber;
StreetName = streetName;
Suburb = suburb;
State = state;
PostCode = postCode;
}
/// <summary>
/// Method for drawing wepons
/// </summary>
/// <param name="elapsedTime">Elapsed time in milleseconds</param>
/// <param name="unitState">Unit state</param>
/// <param name="weaponAnimation">Wepon animation</param>
/// <param name="unit">Unit object</param>
private void DrawWeapon(float elapsedTime, Model.State unitState, Model.State weaponAnimation, Model.Unit unit)
{
//Drawing wepons
if (unit.IsAttacking && !unit.IsCastingSpell)// && m_player.IsAlive())//Player is alive: bugfix, not needed
{
if (weaponAnimation > 0)
{
#region Displacement
int displacementX = 0;
int displacementY = 0;
if (weaponAnimation == Model.State.FACING_CAMERA ||
weaponAnimation == Model.State.MOVING_DOWN)
{
displacementX = -11;
displacementY = 25;
if (unit.GetType() == Model.GameModel.ENEMY_NPC)
{
displacementX = -5;
}
}
else if (weaponAnimation == Model.State.MOVING_UP)
{
displacementX = +11;
displacementY = -10;
}
else if (weaponAnimation == Model.State.MOVING_LEFT)
{
displacementX = -20;
displacementY = +5;
if (unit.GetType() == Model.GameModel.ENEMY_NPC)
{
displacementX = -10;
displacementY = +12;
}
}
else
{
displacementX = +20;
displacementY = +5;
if (unit.GetType() == Model.GameModel.ENEMY_NPC)
{
displacementX = +22;
displacementY = +15;
}
}
#endregion
Vector2 swordPosition = _camera.VisualizeCordinates(unit.ThisUnit.Bounds.X + displacementX, unit.ThisUnit.Bounds.Y + displacementY);
_animationSystem.UpdateAndDraw(_swordTime, Color.White, swordPosition, weaponAnimation, AnimationSystem.Texture.WEAPON_SWORD);
}
}
_swordTime = 0;
}
public override Model.Action getAction(Model.State state)
{
SearchPair pair = search(state, depth, state.isP1Turn);
if (pair.act == null)
{
Debug.Log("AI: Lookahead strategy found null move. Was it called on a terminal state?");
return(null);
}
return(pair.act);
}
public override double evaluate(Model.State state)
{
bool oldMove = state.isP1Turn;
state.isP1Turn = true;
int P1Mobility = state.getLegalMoves().Count;
state.isP1Turn = false;
int P2Mobility = state.getLegalMoves().Count;
state.isP1Turn = oldMove;
return(normalize(P1Mobility - P2Mobility));
}
public override double evaluate(Model.State state)
{
double total = 0.0;
if (state.isTerminal)
{
return((double)state.winStatus);
}
foreach (KeyValuePair <StateEvaluator, double> kvp in evals)
{
total += kvp.Value * kvp.Key.evaluate(state);
}
return(normalize(total));
}
internal Bar(Model.Bar modelBar, Model.Bar likeOther = null)
{
state = modelBar.state;
Width = 220;
Height = 190;
for (int i = 0; i < 6; ++i)
{
newHorizontal(20, 200, lineY(i));
}
newLabel(
lineY(5),
timeX(0, LabelType.BarNumber),
modelBar.barNumber.number.ToString(),
LabelType.BarNumber
);
string comment = modelBar.barNumber.comment;
if (string.IsNullOrEmpty(comment) && (likeOther != null))
{
comment = string.Format("(like {0})", likeOther.barNumber.number);
}
if (!string.IsNullOrEmpty(comment))
{
newLabel(
lineY(-1),
timeX(0, LabelType.Comment),
comment,
LabelType.Comment
);
}
if (likeOther != null)
{
showContents(likeOther);
}
else
{
showContents(modelBar);
}
this.Background = backgroundBrush;
}
/// <summary>
/// Method for drawing of map Items as well as setting the players item targets
/// </summary>
/// <param name="elapsedTime">Elapsed time in milleseconds</param>
private void DrawItems(float elapsedTime, Model.Player player)
{
List <Model.Item> items = _gameModel.ItemSystem._items;
foreach (Model.Item item in items)
{
if (_inputHandler.MouseIsOver(_camera.VisualizeRectangle(item.ThisItem.Bounds)))
{
_inputHandler.MouseIsOverLoot = true;
}
//Checks if the player targeted an item
if (_inputHandler.DidGetTargetedByLeftClick(_camera.VisualizeRectangle(item.ThisItem.Bounds)))
{
player.ItemTarget = item;
}
if (player.ItemTarget == item)
{
if (_inputHandler.DidGetTargetedByLeftClick(_camera.VisualizeRectangle(item.ThisItem.Bounds)) &&
player.ItemTarget.ThisItem.Bounds.Intersects(player.CollisionArea) && !_lootWatch.IsRunning)
{
item.WasLooted = true;
}
else
{
item.WasLooted = false;
}
}
if (item.GetType() == Model.GameModel.ARMOR)
{
Model.Armor Armor = item as Model.Armor;
if (Armor.Type == Model.Armor.HEAD_ARMOR)
{
Vector2 position = _camera.VisualizeCordinates(Armor.ThisItem.Bounds.Location.X, Armor.ThisItem.Bounds.Location.Y);
Model.State itemAnimation = 0;
itemAnimation = Model.State.FACING_CAMERA;
_animationSystem.UpdateAndDraw(elapsedTime, Color.White, position, itemAnimation, AnimationSystem.Texture.ITEM_PURPLE_CHEST);
}
}
}
}
/// <summary>
/// Method for drawing player armor
/// </summary>
/// <param name="elapsedTime">Elapsed time in milleseconds</param>
/// <param name="player">Player object</param>
/// <param name="unitState">Unit state</param>
/// <param name="armorTextureIndex">Texture index for the armor</param>
private void DrawArmor(float elapsedTime, Model.Player player, Model.State unitState, AnimationSystem.Texture armorTextureIndex)
{
Vector2 armorPlacement = Vector2.Zero;
switch (armorTextureIndex)
{
case AnimationSystem.Texture.ARMOR_HEAD:
armorPlacement = _camera.VisualizeCordinates(player.ThisUnit.Bounds.X, player.ThisUnit.Bounds.Y);
break;
}
Model.State armorAnimation;
if (unitState == Model.State.MOVING_DOWN)
{
armorAnimation = Model.State.FACING_CAMERA;
}
else if (unitState == Model.State.MOVING_UP)
{
armorAnimation = Model.State.FACING_AWAY;
}
else if (unitState == Model.State.MOVING_LEFT)
{
armorAnimation = Model.State.FACING_LEFT;
}
else if (unitState == Model.State.MOVING_RIGHT)
{
armorAnimation = Model.State.FACING_RIGHT;
}
else if (unitState == Model.State.IS_CASTING_HEAL)
{
armorAnimation = Model.State.FACING_CAMERA;
}
else
{
armorAnimation = unitState;
}
_animationSystem.UpdateAndDraw(elapsedTime, Color.White, armorPlacement, armorAnimation, AnimationSystem.Texture.ARMOR_HEAD);
}
private SearchPair search(Model.State state, int depth, bool max)
{
List <Model.Action> legalActs = state.getLegalMoves();
if (legalActs == null || legalActs.Count == 0)
{
if (!state.isTerminal)
{
Debug.Log("Problem with Model.State: No legal moves but game not over!");
}
else
{
return(new SearchPair(null, (double)state.winStatus));
}
}
SearchPair bestPair = null;
SearchPair thisPair = null;
double bestEval;
if (max)
{
bestEval = -1.0;
}
else
{
bestEval = 1.0;
}
foreach (Model.Action act in legalActs)
{
if (depth <= 1)
{
thisPair = new SearchPair(act, this.eval.evaluate(new Model.State(state, act)));
}
else
{
thisPair = search(new Model.State(state, act), depth - 1, !max);
}
if ((max && thisPair.eval >= bestEval) || (!max && thisPair.eval <= bestEval))
{
bestEval = thisPair.eval;
bestPair = new SearchPair(act, bestEval);
}
}
return(bestPair);
}
public static IEnumerable <Model.State> ConvertToModel(IEnumerable <Entity.State> listEntity)
{
IList <Model.State> listState = new List <Model.State>();
try{
foreach (var entity in listEntity)
{
Model.State state = new Model.State();
state.countryId = entity.countryId;
state.stateId = entity.stateId;
state.stateName = entity.name;
listState.Add(state);
}
}
catch (Exception ex)
{
return(null);
}
return(listState);
}
public override double evaluate(Model.State state)
{
int P1 = 0;
int P2 = 0;
foreach (Piece p in state.player1)
{
if (p.color == "black")
{
P1++;
}
}
foreach (Piece p in state.player2)
{
if (p.color == "black")
{
P2++;
}
}
return(normalize(P1 - P2));
}
/// <summary>
/// Adds a state to this fpc (both model and viewModel) and stick it to mouse
/// </summary>
private void addStateByTool()
{
var stateModel = new Model.State
{
StateType = StateType.Mid,
X = -50,
Y = -20,
FPC = Model,
};
this.Model.States.Add(stateModel);
_newDraggingStateVm = new StateVm(stateModel, this, false)
{
Opacity = 0.4d,
};
_newDraggingStateVm.Config = new StateConfigVm(_newDraggingStateVm);
this.States.Add(_newDraggingStateVm);
DragTarget = _newDraggingStateVm;
RelativeDragPoint = new Point(50, 20);
}
/// <summary>
/// Updating and drawing via UpdateFrame and DrawFrame
/// </summary>
/// <param name="elapsedTime">Elapsed time in milleseconds</param>
/// <param name="texturePos">Screen position</param>
/// <param name="color">Color(fading)</param>
/// <param name="animation">Animation/Object-state</param>
/// <param name="texture">Texture index</param>
internal void UpdateAndDraw(float elapsedTime, Color color, Vector2 texturePos, Model.State animation, Texture texture)
{
int frameY = -1;
int frameX = -1;
bool staticAnimation = false;
bool verticalAnimation = false;
switch (animation)
{
case Model.State.MOVING_DOWN:
frameY = 0;
break;
case Model.State.SMITE:
frameY = 0;
break;
case Model.State.MOVING_UP:
frameY = 3;
break;
case Model.State.MOVING_RIGHT:
frameY = 2;
break;
case Model.State.MOVING_LEFT:
frameY = 1;
break;
case Model.State.FACING_CAMERA:
frameY = 0;
staticAnimation = true;
break;
case Model.State.FACING_LEFT:
frameY = 1;
staticAnimation = true;
break;
case Model.State.FACING_RIGHT:
frameY = 2;
staticAnimation = true;
break;
case Model.State.FACING_AWAY:
frameY = 3;
staticAnimation = true;
break;
case Model.State.IS_DEAD:
frameY = 5;
staticAnimation = true;
break;
case Model.State.WAS_HEALED:
break;
case Model.State.IS_CASTING_FIREBALL:
frameY = 4;
break;
case Model.State.IS_CASTING_HEAL:
frameY = 6;
break;
case Model.State.VERTICAL_ANIMATION:
frameX = 1;
verticalAnimation = true;
break;
}
if (staticAnimation)
{
_spriteTextures[Convert.ToInt32(texture)].StaticTexture(frameY);
}
else if (verticalAnimation)
{
_spriteTextures[Convert.ToInt32(texture)].VerticalAnimation(elapsedTime, frameX);
}
else
{
_spriteTextures[Convert.ToInt32(texture)].HorizontalAnimation(elapsedTime, frameY);
}
_spriteTextures[Convert.ToInt32(texture)].DrawFrame(_spriteBatch, texturePos, color);
}
public override double evaluate(Model.State state)
{
return(normalize(state.player1.Count - state.player2.Count));
}
public abstract Model.Action getAction(Model.State state);
public override Model.Action getAction(Model.State state)
{
List <Model.Action> actions = state.getLegalMoves();
return(actions[rnd.Next(actions.Count)]);
}
public abstract double evaluate(Model.State state);
