protected void DetectPadCollision(IBall ball)
{
IPad pad = null;
bool collisionDetected = false;
foreach (var value in padManager)
{
pad = value.Item3;
if (collisionManager.Detect(pad, ball))
{
collisionDetected = true;
CorrectBallPosition(pad, ball);
if (pad.Speed > padSpeedToGoBallFaster)
{
ball.SetFasterSpeed();
}
break;
}
}
if (collisionDetected)
{
collisionState.SetPadCollistionState(true, true, pad);
}
}
private void CorrectBallPosition(IPad pad, IBall ball)
{
while (collisionManagerForMoveReversion.Detect(pad, ball))
{
if (!ball.MoveBall(true))
{
game.RestartBallYPosition(pad, ball);
return;
}
ball.SavePosition();
foreach (IBorder border in borderManager)
{
if (collisionManagerForMoveReversion.Detect(border, ball))
{
game.SetBallStartPosition(pad, ball);
break;
}
}
if (screenCollisionManager.DetectAndVerify(ball))
{
game.SetBallStartPosition(pad, ball);
break;
}
}
}
private void ExecuteAdditionalEffect(BrickType type)
{
switch (type)
{
case BrickType.ThreeBalls:
{
IPad pad = padManager.GetFirst();
IBall ball1 = new Ball(randomGenerator);
ball1.SetSize(15, 15);
SetBallStartPosition(pad, ball1);
ballManager.Add(ball1);
IBall ball2 = new Ball(randomGenerator);
ball2.SetSize(15, 15);
SetBallStartPosition(pad, ball2);
ballManager.Add(ball2);
break;
}
case BrickType.DestroyerBall:
{
foreach (IBall ball in ballManager)
{
tailManager.Add(ball);
}
break;
}
default:
break;
}
}
private void CorrectBallPosition(IPad pad, IBall ball)
{
Vector2 previous = ball.Boundary.Min;
while (collisionManagerForMoveReversion.Detect(pad, ball))
{
if (!ball.MoveBall(true))
{
ball.Boundary.Min = previous;
padManager.RestartBallYPosition(pad, ball);
return;
}
previous = ball.Boundary.Min;
ball.SavePosition();
foreach (IBorder border in borderManager)
{
if (collisionManagerForMoveReversion.Detect(border, ball))
{
padManager.SetBallStartPosition(pad, ball);
break;
}
}
if (screenCollisionManager.DetectAndVerify(ball))
{
padManager.SetBallStartPosition(pad, ball);
break;
}
}
ball.Boundary.Min = previous;
}
public void Create(IBall ball, BrickType type)
{
switch (type)
{
case BrickType.ThreeBalls:
{
IPad pad = ballManager.GetPadAssignedToBall(ball);
ballBuilder.Create(pad);
ballBuilder.Create(pad);
break;
}
case BrickType.DestroyerBall:
{
ITail tail = new Tail {
FireBallTimerCallback = fireBallCounter.FireBallTimerHandler
};
tailManager.Add(ball, tail);
break;
}
default:
break;
}
}
public IActionResult Edit(int id, [Bind("Id,IPadModel,TypeOfModel,Memory,Type," +
"ScreenType,ScreenSize,Processor," +
"Ram,MainCamera,FrontCamera,YearOfProduction,Color," +
"Price,Description,AmountOfProduct")] IPad iPad)
{
if (id != iPad.Id)
{
return(NotFound());
}
var ipd = _iPadRepository.GetIPadByProp(x => x.Id == id);
_iPadRepository.EditIPad(ipd, x =>
{
x.IPadModel = iPad.IPadModel;
x.TypeOfModel = iPad.TypeOfModel;
x.Memory = iPad.Memory;
x.Type = iPad.Type;
x.ScreenType = iPad.ScreenType;
x.ScreenSize = iPad.ScreenSize;
x.Processor = iPad.Processor;
x.Ram = iPad.Ram;
x.MainCamera = iPad.MainCamera;
x.FrontCamera = iPad.FrontCamera;
x.YearOfProduction = iPad.YearOfProduction;
x.Color = iPad.Color;
x.Price = iPad.Price;
x.Description = iPad.Description;
x.AmountOfProduct = iPad.AmountOfProduct;
});
return(RedirectToAction("Details", "IPad", new IPad {
Id = id
}));
}
/// <summary>
/// Hides the given pad, if it exists
/// </summary>
/// <param name="pad"></param>
public void HidePad(IPad pad)
{
if (m_padLookup.ContainsKey(pad))
{
m_padLookup[pad].Hide();
}
}
public bool action(IBall ball)
{
IPad pad = padManager.GetFirst();
padManager.SetBallStartPosition(pad, ball);
return(true);
}
private bool FindEdge(IPad pad, out Edge edge)
{
var padPair = pads.FirstOrDefault(p => p.Item3 == pad);
edge = padPair?.Item1 ?? Edge.Bottom;
return(padPair != null);
}
/// <summary>
/// Hides the given pad, if it exists
/// </summary>
/// <param name="pad"></param>
public void HidePad(IPad pad)
{
if (m_padLookup.ContainsKey(pad))
{
DockManager.Hide(m_padLookup[pad]);
}
}
public void Create(IPad pad)
{
IBall ball = Create();
padManager.SetBallStartPosition(pad, ball);
ballManager.Add(ball, pad);
}
public void SetBallMove()
{
foreach (IBall ball in ballManager)
{
IPad pad = padManager.GetFirst();
SetBallStartPosition(pad, ball);
}
}
public void DeleteIPad(IPad iPad)
{
if (iPad != null)
{
_db.Remove(iPad);
}
_db.SaveChanges();
}
public bool action(IBall ball)
{
if (!game.ShouldGo)
{
IPad pad = padManager.GetFirst();
game.SetBallStartPosition(pad, ball);
}
return(true);
}
public void EditIPad(IPad iPad, Action <IPad> editAction)
{
var ipd = GetIPadByProp(x => x.Id == iPad.Id);
if (ipd != null)
{
editAction(ipd);
}
_db.SaveChanges();
}
private void VerifyBorderCollision(IPad pad)
{
foreach (IBorder border in borderManager)
{
IBorderCollisionManager borderCollisionManager = new BorderCollisionManager(border, collisionManager);
if (borderCollisionManager.DetectAndVerify(pad))
{
break;
}
}
}
public bool DetectAndVerify(IEnumerable <IBorder> borders, IPad pad)
{
foreach (IBorder border in borders)
{
if (DetectAndVerify(border, pad))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Returns true if the given pad is visible.
/// </summary>
/// <param name="pad"></param>
/// <returns></returns>
public bool IsVisible(IPad pad)
{
if (m_padLookup.ContainsKey(pad))
{
DockableContent content = m_padLookup[pad];
return(content.State != DockableContentState.Hidden);
}
else
{
return(false);
}
}
public IActionResult Create([Bind("Id,IPadModel,TypeOfModel,Memory,Type," +
"ScreenType,ScreenSize,Processor," +
"Ram,MainCamera,FrontCamera,YearOfProduction,Color," +
"Price,Description,AmountOfProduct")] IPad iPad)
{
if (ModelState.IsValid)
{
_iPadRepository.CreateIPad(iPad);
return(RedirectToAction("Details", "IPad", new IPad {
Id = iPad.Id
}));
}
return(View());
}
public void SetPadMove(int delta, uint manipulator)
{
foreach (var value in padManager.Where(x => x.Item2 == manipulator))
{
IPad pad = value.Item3;
pad.Speed = delta;
pad.Boundary.Min = new Vector2(pad.Boundary.Min.X + pad.Speed, pad.Boundary.Min.Y);
screenCollisionManager.DetectAndVerify(pad);
borderCollisionManager.DetectAndVerify(borderManager, pad);
}
}
public bool DetectAndVerify(IPad pad)
{
if (pad.Boundary.Min.X <= 0)
{
pad.Boundary.Min = new Vector2(0, pad.Boundary.Min.Y);
}
if (pad.Boundary.Min.X > screen.Width - pad.Boundary.Size.X)
{
pad.Boundary.Min = new Vector2(screen.Width - pad.Boundary.Size.X, pad.Boundary.Min.Y);
}
return(false);
}
public void Create(IGameConfig gameConfig)
{
ballManager.Clear();
tailManager.Clear();
var padIterator = padManager.GetEnumerator();
for (int i = 0; i < gameConfig.Players && i < gameConfig.Mouses; ++i)
{
padIterator.MoveNext();
IPad pad = padIterator.Current.Item3;
Create(pad);
}
}
public void GetPadPosition(IPad pad, out int posx, out int posy)
{
posx = 0;
posy = 0;
IElement padElement = pad as IElement;
if (padElement == null)
{
return;
}
posx = padElement.PosX;
posy = padElement.PosY;
}
static void Main(string[] args)
{
IPad iPad = new IPad("Ipad mini", "Apple");
GalaxyTab galaxyTab = new GalaxyTab("Galaxy Tab", "Samsung");
iPad.Accept(new WifiVisitor());
galaxyTab.Accept(new WifiVisitor());
iPad.Accept(new ThreeGVisitor());
galaxyTab.Accept(new ThreeGVisitor());
//* bunun gibi baska visitor sınıfları yazarak sınıfımızı değiştirmeden
//* yeni metotlar çalıştırabilir hale getirebiliriz.
Console.ReadLine();
}
public void RestartBallYPosition(IPad pad, IBall ball)
{
Logger.Instance.Write("---RestartBallYPosition---");
IElement ballElement = ball as IElement;
IElement padElement = pad as IElement;
if (ballElement == null || padElement == null)
{
return;
}
ballElement.PosY = padElement.PosY + padElement.Height;
ball.OffsetY = ballElement.PosY;
ball.SavedPosY = ballElement.PosY;
}
/// <summary>
/// Shows a pad. If it hasn't been shown before, it shows it
/// docked to the right side. Otherwise it restores it to the
/// previous place that it was before hiding. Doesn't work
/// correctly for floating panes (yet).
/// </summary>
/// <param name="pad"></param>
public void ShowPad(IPad pad)
{
if (!m_padLookup.ContainsKey(pad))
{
DockableContent content = new DockableContent();
setManagedContentProperties(pad, content);
m_padLookup.Add(pad, content);
DockablePane dp = new DockablePane();
dp.Items.Add(content);
m_resizingPanel.Children.Add(dp);
pad.PropertyChanged += new PropertyChangedEventHandler(pad_PropertyChanged);
content.GotFocus += new RoutedEventHandler(pad.OnGotFocus);
content.LostFocus += new RoutedEventHandler(pad.OnLostFocus);
}
m_padLookup[pad].Show(DockManager);
}
public void DrawPad()
{
foreach (var value in padManager)
{
IPad pad = value.Item3;
pad.GetPosition(out int posX, out int posY);
pad.GetSize(out int width, out int height);
VertexArray rect = new VertexArray(PrimitiveType.Quads, 4);
rect.Append(new Vertex(new Vector2f(posX, posY), Color.White));
rect.Append(new Vertex(new Vector2f(posX + width, posY), Color.White));
rect.Append(new Vertex(new Vector2f(posX + width, posY + height), Color.Blue));
rect.Append(new Vertex(new Vector2f(posX, posY + height), Color.Blue));
render.Draw(rect);
}
}
private void ReinitBall()
{
tailManager.Clear();
ballManager.LeaveOnlyOne();
IBall ball = ballManager.GetFirst();
if (ball == null)
{
return;
}
IPad pad = padManager.GetFirst();
SetBallStartPosition(pad, ball);
}
/// <inheritdoc/>
public Option <IPad, string> Link(IPad peer)
{
if (peer == this.Peer)
{
return(Option.Some <IPad, string>(peer));
}
if (peer is ISrcPad <TValue> truePeer)
{
this.Peer = truePeer;
return(Option.Some <IPad, string>(peer));
}
else
{
return(Option.None <IPad, string>("Could not link Pads be casue the types didn't match"));
}
}
/// <summary>
/// Shows a pad. If it hasn't been shown before, it shows it
/// docked to the right side. Otherwise it restores it to the
/// previous place that it was before hiding. Doesn't work
/// correctly for floating panes (yet).
/// </summary>
/// <param name="pad"></param>
public void ShowPad(IPad pad, DockableContentState desideredState = DockableContentState.Docked)
{
if (!m_padLookup.ContainsKey(pad))
{
DockableContent content = new DockableContent();
content.Content = pad;
content.Title = pad.Title;
content.Name = pad.Name;
content.Icon = pad.Icon;
if (pad.DesideredState == DockableContentState.AutoHide)
{
content.Loaded += new RoutedEventHandler(AutoHideAfterLoaded);
}
m_padLookup.Add(pad, content);
DockablePane dp;
switch (pad.Location)
{
case PadLocation.TopLeft:
dp = m_topLeftPane;
break;
case PadLocation.TopRight:
dp = m_topRightPane;
break;
case PadLocation.Bottom:
default:
dp = m_bottomPane;
break;
}
dp.Items.Add(content);
content.GotFocus += new RoutedEventHandler(pad.OnGotFocus);
content.LostFocus += new RoutedEventHandler(pad.OnLostFocus);
}
if (desideredState == DockableContentState.AutoHide ||
desideredState == DockableContentState.FloatingWindow)
{
DockManager.Show(m_padLookup[pad], desideredState);
}
else
{
DockManager.Show(m_padLookup[pad]);
}
}
/// <summary>
/// Hides the given pad, if it exists
/// </summary>
/// <param name="pad"></param>
public void HidePad(IPad pad)
{
if (m_padLookup.ContainsKey(pad))
{
m_padLookup[pad].Hide();
}
}
/// <summary>
/// Returns true if the given pad is visible.
/// </summary>
/// <param name="pad"></param>
/// <returns></returns>
public bool IsVisible(IPad pad)
{
if (m_padLookup.ContainsKey(pad))
{
DockableContent content = m_padLookup[pad];
return (content.State != DockableContentState.Hidden);
}
else
{
return false;
}
}
/// <summary>
/// Shows a pad. If it hasn't been shown before, it shows it
/// docked to the right side. Otherwise it restores it to the
/// previous place that it was before hiding. Doesn't work
/// correctly for floating panes (yet).
/// </summary>
/// <param name="pad"></param>
public void ShowPad(IPad pad)
{
if (!m_padLookup.ContainsKey(pad))
{
DockableContent content = new DockableContent();
setManagedContentProperties(pad, content);
m_padLookup.Add(pad, content);
DockablePane dp = new DockablePane();
dp.Items.Add(content);
m_resizingPanel.Children.Add(dp);
pad.PropertyChanged += new PropertyChangedEventHandler(pad_PropertyChanged);
content.GotFocus += new RoutedEventHandler(pad.OnGotFocus);
content.LostFocus += new RoutedEventHandler(pad.OnLostFocus);
}
m_padLookup[pad].Show(DockManager);
}
public CBCMode(BlowfishKey key, IPad padding = null)
{
_key = key;
_blockSize = key.GetBlockSize();
_padding = padding;
if (_padding == null)
_padding = new PKCS5();
_padding.SetBlockSize(_blockSize);
// _random = new PRNG();
_IV = null;
}
