Need help with questions 2-4. Write assembly code to find absolute v.pdf

Need help with questions 2-4. Write assembly code to find absolute values of a data word (2 byte
word) stored at address $0200 and write the absolute value at $0300. Two 16-bit signed values
are stored at $0A00 (they each take 2 bytes). Please write assembly code to sort them in
descending order (so that $0A02 has the smallest, and $0A00 has the largest). Could you sort the
same way for 50 such words? Write a piece of Assembly code to (a) allocate a string named
message to contain good day! (all the underlined characters) at location $0F00; (b) How many
bytes would it need?; (c) The rest of the code you write should compare the contents in register
A with each character in this message. If a match is found, put the NULL character in register A,
and get register B to contain the character G (ascii value). Write HCS12 assembly code to do the
following. Using ORG and DC.W directives declare and initialize a data array of 8 words (1
word = 1 integer in I ICS 12 - 2 bytes) starting at address S0200. Their initial values are to be
A367, F238,0012, 1972, 1132, AB88, 7399, and 1864. You can name the array EightInts (see
class notes or text examples). Now start your program code at $4000 (ORG directive).
Configure the direction of port A, port B, and port H to be inputs (i.e. set data directional
registers). We are going to consider port A as the high byte, and port B as low byte of data words
we want to read and compare against eighties using a loop. The idea is to see whether port A and
port B values taken as a 2 byte integer is equal to any of the values in eightins. Before starting to
compare values, the program waits until port H is all 1's then it reads port A, and port B before
comparing against eighties. if a match is found, your program branches to label found and stay at
that instruction. If no match, the program should branch to no luck label and stay there.
Solution
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.util.*;
//Primary class for the game
public class Asteroids extends Applet implements Runnable, KeyListener{
/**
*
*/
private static final long serialVersionUID = 1L;

//the main thread becomes the game loop
Thread gameloop;
//use this as a double buffer
BufferedImage backbuffer;
//the main drawing object for the back buffer
Graphics2D g2d;
//toggle for drawing bounding boxes
boolean showBounds = false;
//create the asteroid array
int ASTEROIDS = 20;
Asteroid[] ast = new Asteroid[ASTEROIDS];
//create the bullet array
int BULLETS = 10;
Bullet[] bullet = new Bullet[BULLETS];
int currentBullet = 0;
//the player's ship
Ship ship = new Ship();
//create the identity transform (0.0)
AffineTransform identity = new AffineTransform();
//create a random number generator
Random rand = new Random();
//applet init event
public void init(){
//create the back buffer for smooth graphics
backbuffer = new BufferedImage(640, 480,BufferedImage.TYPE_INT_RGB);
g2d = backbuffer.createGraphics();

//set up the ship
ship.setX(320);
ship.setY(240);
//set up the bullets
for (int n = 0; n < BULLETS; n++) {
bullet[n] = new Bullet();
}
//Create the asteroids
for (int n = 0; n < ASTEROIDS; n++) {
ast[n] = new Asteroid();
ast[n].setRotationVelocity(rand.nextInt(3)+1);
ast[n].setX((double)rand.nextInt(600)+20);
ast[n].setY((double)rand.nextInt(440)+20);
ast[n].setMoveAngle(rand.nextInt(360));
double ang = ast[n].getMoveAngle() - 90;
ast[n].setVelX(calcAngleMoveX(ang));
ast[n].setVelY(calcAngleMoveY(ang));
}
//start the user input listener
addKeyListener(this);
}
// applet update event to redraw the screen
public void udpate(Graphics g) {
//start off the transforms at identity
g2d.setTransform(identity);
//erase the background
g2d.setPaint(Color.BLACK);
g2d.fillRect(0, 0, getSize().width, getSize().height);
//print some status information

g2d.setColor(Color.WHITE);
g2d.drawString("Ship: "+ Math.round(ship.getX()) + "," + Math.round(ship.getY()), 5 ,
10);
g2d.drawString("Move angle: " + Math.round(ship.getMoveAngle()) + 90, 5, 25);
g2d.drawString("Face angle: " + Math.round(ship.getFaceAngle()),5 , 40);
//draw the game graphics
drawShip();
drawBullets();
drawAsteroids();
//repaint the applet window
paint(g);
}
//drawShip called by applet udpate event
public void drawShip() {
g2d.translate(ship.getX(), ship.getY());
g2d.rotate(Math.toRadians(ship.getFaceAngle()));
g2d.setColor(Color.ORANGE);
g2d.fill(ship.getShape());
}
//drawbullets called by applet udpate event
public void drawBullets() {
//iterate through the array of bullets
for (int n = 0; n < BULLETS; n++){
//is this bullet currently in use?
if (bullet[n].isAlive()) {
//draw bullet
g2d.translate(bullet[n].getX(), bullet[n].getY());
g2d.setColor(Color.MAGENTA);
g2d.draw(bullet[n].getShape());

}
}
}
//drawAsteroids called by applet update event
public void drawAsteroids() {
//is this asteroid being used?
if (ast[n].isAlive()){
//draw asteroid
g2d.translate(ast[n].getX(), ast[n].getY());
g2d.rotate(Math.toRadians(ast[n].getMoveAngle()));
g2d.setColor(Color.DARK_GRAY);
g2d.fill(ast[n].getShape());
}
}
}
//applet window repaint event draw the back buffer
public void paint(Graphics g) {
//draw the back buffer onto the applet window
g.drawImage(backbuffer, 0, 0, this );
}
// thread start event - start the game loop running
public void start() {
//create the gameloop thread for real - time updates
gameloop = new Thread(this);
gameloop.start();
}
// thread run event (game loop)

public void run() {
//acquire the current thread
Thread t = Thread.currentThread();
//keep going as long as the thread is alive
while (t == gameloop) {
try {
//update gameloop
gameUpdate();
//target framerate is 50fps
Thread.sleep(20);
}
catch(InterruptedException e) {
e.printStackTrace();
}
repaint();
}
}
//thread stop event
public void stop() {
//kill the gameloop thread
gameloop = null;
}
//move and animate the objects in the game
private void gameUpdate() {
updateShip();
updateBullets();
updateAsteroids();
checkCollisions();
}

//update the ship position based on velocity
public void updateShip() {
//update ships X position
ship.incX(ship.getVelX());
//warp around left/right
if (ship.getX() < -10)
ship.setX(getSize().width + 10);
else if (ship.getX() > getSize().width + 10)
ship.setX(-10);
//update ships Y position
ship.incY(ship.getVelY());
//wrap around top/bottom
if (ship.getY() < -10)
ship.setY(getSize().height + 10);
else if (ship.getY() > getSize().height + 10)
ship.setY(-10);
}
// update the bullets based on velocity
public void updateBullets() {
//move each of the bullets
//is this bullet being used?
//update bullets x position
bullet[n].incX(bullet[n].getVelX());
//bullet disappears at left/right edge
if (bullet[n].getX() < 0 || bullet[n].getX() > getSize().width) {
bullet[n].setAlive(false);

}
//update bullets y position
bullet[n].incY(bullet[n].getVelY());
//bullet disappears at top/bottom edge
if (bullet[n].getY() < 0 || bullet[n].getY() > getSize().height) {
}
}
}
}
//update the asteroids based on velocity
public void updateAsteroids() {
//move and rotate the asteroids
//is this asteroid being used?
if (ast[n].isAlive()) {
//update asteroid X value
ast[n].incX(ast[n].getVelX());
//warp the asteroid at the screen edges
if (ast[n].getX() < -20)
ast[n].setX(getSize().width + 20);
else if (ast[n].getX() > getSize().width +20)
ast[n].setX(-20);
//update the asteroid Y value
ast[n].incY(ast[n].getVelY());
//warp around bottom and top of screen

if (ast[n].getY() < -20)
ast[n].setY(getSize().height + 20);
else if (ast[n].getY() > getSize().height +20)
ast[n].setY(-20);
//update the asteroids rotation
ast[n].incMoveAngle(ast[n].getRotationVelocity());
//keep the angle within 0-359 degrees
if (ast[n].getMoveAngle() < 0)
ast[n].setMoveAngle(360 - ast[n].getRotationVelocity());
else if (ast[n].getMoveAngle() > 360)
ast[n].setMoveAngle(ast[n].getRotationVelocity());
}
}
}
//test asteroids for collisions with ship or bullets
public void checkCollisions() {
//iterate through the asteroids array
for (int m = 0; m < ASTEROIDS; m++) {
// is this asteroid being used?
if (ast[m].isAlive()) {
//check for collision with bullet
//is this bullet being used?
//perform the collision test
if (ast[m].getBounds().contains(bullet[n].getX(), bullet[n].getY())) {
ast[m].setAlive(false);
continue;
}

}
}
//check for collision with ship
if(ast[m].getBounds().intersects(ship.getBounds())) {
ast[m].setAlive(false);
ship.setX(320);
ship.setY(240);
ship.setFaceAngle(0);
ship.setVelX(0);
ship.setVelY(0);
continue;
}
}
}
}
//key listener events
public void keyReleased(KeyEvent k) {}
public void keyTyped(KeyEvent k) {}
public void keyPressed(KeyEvent k) {
int keyCode = k.getKeyCode();
switch (keyCode) {
case KeyEvent.VK_LEFT:
//left arrow rotates ship left 5 degrees
ship.incFaceAngle(-5);
if(ship.getFaceAngle() < 0) ship.setFaceAngle(360-5);
break;
case KeyEvent.VK_RIGHT:
//right arrow rotates ship right 5 degrees
ship.incFaceAngle(5);
if(ship.getFaceAngle() > 360) ship.setFaceAngle(5);
break;
case KeyEvent.VK_UP:
//up arrow thrust to ship (1/10 normal speed)
ship.setMoveAngle(ship.getFaceAngle() - 90);

ship.incVelX(calcAngleMoveX(ship.getMoveAngle()) * 0.1);
ship.incVelY(calcAngleMoveY(ship.getMoveAngle()) * 0.1);
break;
//CTRL ENTER OR SPACE used to fire weapon
case KeyEvent.VK_CONTROL:
case KeyEvent.VK_ENTER:
case KeyEvent.VK_SPACE:
//fire a bullet
currentBullet++;
if(currentBullet > BULLETS - 1) currentBullet = 0;
bullet[currentBullet].setAlive(true);
//point bullet in same direction as ship is facing
bullet[currentBullet].setX(ship.getX());
bullet[currentBullet].setY(ship.getY());
bullet[currentBullet].setMoveAngle(ship.getFaceAngle() - 90);
//fire bullet at angle of ship
double angle = bullet[currentBullet].getMoveAngle();
double svx = ship.getVelX();
double svy = ship.getVelY();
bullet[currentBullet].setVelX(svx + calcAngleMoveX(angle) * 2);
bullet[currentBullet].setVelY(svy + calcAngleMoveY(angle) * 2);
break;
}
}
//calculate X movement value based on direction angle
public double calcAngleMoveX(double angle) {
return (double) (Math.cos(angle * Math.PI / 180));
}
// calculate Y movement value based on direction angle
public double calcAngleMoveY (double angle) {
return (double) (Math.sin(angle * Math.PI / 180));
}

Need help with questions 2-4. Write assembly code to find absolute v.pdf

More Related Content

Similar to Need help with questions 2-4. Write assembly code to find absolute v.pdf (20)

More from feelinggifts (20)

Recently uploaded (20)

Need help with questions 2-4. Write assembly code to find absolute v.pdf