

                <ul class="treeview-menu">
                   <li class="treeview">
                       <a href="{{ route('informasi_barang_masuk') }}">Goods Receipt</a>
                   </li>
                   <li class="treeview">
                       <a href="{{ route('informasi_barang_keluar') }}">Goods Issue</a>
                   </li>
               </ul>
            </li>
            <li>
                <a href="{{ route('jenis_barang.index') }}">Types of Goods</a>
            </li>
            <li>
                <a href="{{ route('lokasi_warehouse.index') }}">Warehouse Location</a>
            </li>

            <li><a href="{{route('logout')}}"
                    onclick="event.preventDefault();document.getElementById('logout-form').submit();">
                    Logout</a>
                <form id="logout-form" action="{{route('logout')}}" method="POST" style="display:none;">
                    @csrf
                </form>
            </li>
        </ul>
    </section>
</aside>
<!--Sidebar End-->
This particular summer morning was a leisurely, overcast one. It was evident by the saturated ground and rich, verdant smell outside that a light rain had fallen the night before and perhaps more would be coming later in the day.
I didn’t have anything on the agenda until later in the afternoon, when I would be meeting some girlfriends for a birthday dinner. And although just yesterday the house was bursting with out-of-town guests, my husband had taken them hiking in the wilderness and the four of them wouldn’t be returning until the next day. The kids were downstairs playing happily in their pajamas, leaving me to linger over my first cup of coffee, then a second, and to ponder what ambling breakfast might suit the day.
The day before, when my 6-year-old daughter and I made a quick trip to the grocery store, she requested a bag of roasted pistachios with sea salt and some fuzzy, ripe apricots. I granted both requests, and when the time came to make breakfast the following morning, both items were sitting on the kitchen counter, practically begging me to make something with them.
Steel-cut oats are perfect for this sort of leisurely breakfast; they do take a while to cook on the stovetop, but they’re pleasantly low-maintenance. Put them on a low simmer for 25 minutes and walk away. Stir in some milk and simmer another 10 minutes while you fix up the toppings. Soon, a beautiful and nutritious breakfast awaits.
Steel-cut oats with honeyed apricots and pistachios
Maya Evoy lives in Nikiski and is the face behind the food blog alaskafromscratch.com.Workers at McKee Barracks in Cabra are concerned for their health.
Soldiers are working in barracks flooded with sewage.
A defence forces representative group claims members based in Cabra have complained of faeces and urine in open air, saying the smell sticks to their clothing even after they leave.
PDFORRA shared the story at its annual conference yesterday.
The Irish Mirror is reporting that soldiers in McKee barracks are concerned about how it will impact their health.
A spokesperson claimed that most days, particularly when it's warm, the soldiers can taste it on their tongue.
He acknowledged that remedial works are due to start soon at the site soon.
However he called for proper maintenance afterwards.
The spokesperson says it's essential to make sure the problem doesn't return.use super::Block;
use super::Colour;

pub struct Game {
    x: isize,
    y: isize,
    block: Block,
    w: isize,
    h: isize,
    board: Vec<Colour>,
    score: isize,
    last_fall: std::time::Instant,
    fall_rate_nanos: u128,
    game_over: bool,
}

impl Game {
    pub fn new(w: isize, h: isize) -> Result<Self, String> {
        if w < 4 || h < 4 {
            Err("too small".to_string())
        } else {
            let mut board: Vec<Colour> = vec![];

            board.resize((w * h) as usize, Colour::Empty);

            let mut g = Self {
                x: 0,
                y: 0,
                block: super::Block::new(),
                w: w,
                h: h,
                board: board,
                score: 0,
                last_fall: std::time::Instant::now(),
                fall_rate_nanos: std::time::Duration::from_millis(1000).as_nanos(),
                game_over: false,
            };

            g.new_game();

            Ok(g)
        }
    }

    pub fn new_game(&mut self) {
        for i in 0..(self.w * self.h) as usize {
            self.board[i] = Colour::Empty;
        }
        self.random();
        self.score = 0;
        self.game_over = false;
    }

    pub fn get_score(&self) -> isize {
        self.score
    }

    pub fn random(&mut self) {
        let (dx, dy) = self.block.random();
        self.x = self.w / 2 + dx;
        self.y = dy;
        self.last_fall = std::time::Instant::now();

        if self.collision(self.x, self.y) {
            self.game_over = true;
        }
    }

    pub fn tick(&mut self) -> bool {
        let now = std::time::Instant::now();
        if now.duration_since(self.last_fall).as_nanos() < self.fall_rate_nanos {
            return false;
        }

        if!self.down() {
            self.merge();
            self.random();
        }

        true
    }

    pub fn dims(&self) -> (isize, isize) {
        (self.w, self.h)
    }

    pub fn get(&self, x: isize, y: isize) -> Colour {
        if x < 0 || x >= self.w || y < 0 || y >= self.h {
            Colour::Empty
        } else {
            let index = (y * self.w + x) as usize;
            self.board[index]
        }
    }

    pub fn display_get(&self, x: isize, y: isize) -> Colour {
        if x < 0 || x >= self.w || y < 0 || y >= self.h {
            Colour::Empty
        } else {
            if self.block.get(x - self.x, y - self.y) {
                self.block.colour()
            } else {
                let index = (y * self.w + x) as usize;
                self.board[index]
            }
        }
    }

    pub fn filled(&self, x: isize, y: isize) -> bool {
        match self.get(x, y) {
            Colour::Empty => false,
            _ => true,
        }
    }

    fn set(&mut self, x: isize, y: isize, colour: Colour) {
        if x < 0 || x >= self.w || y < 0 || y >= self.h {
            return;
        }

        let index = (y * self.w + x) as usize;
        self.board[index] = colour;
    }

    fn out_of_bounds(&self, x: isize, y: isize) -> bool {
        let (bw, bh) = self.block.dims();

        for by in 0..bh {
            for bx in 0..bw {
                if self.block.get(bx, by) {
                    let x = x + bx;
                    let y = y + by;
                    if x < 0 || x >= self.w || y < 0 || y >= self.h {
                        return true;
                    }
                }
            }
        }

        false
    }

    fn collision(&self, x: isize, y: isize) -> bool {
        let (bw, bh) = self.block.dims();

        for by in 0..bh {
            for bx in 0..bw {
                if self.block.get(bx, by) {
                    if self.filled(x + bx, y + by) {
                        return true;
                    }
                }
            